././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7178009 buildstream_plugins-2.7.0/0000755000175100017510000000000015152545044014655 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/.asf.yaml0000644000175100017510000000155315152545021016367 0ustar00juergjuerg # # Avoid diluting the dev mailing list with meta stuff, # redirect it all to the commit list. # notifications: commits: commits@buildstream.apache.org issues: commits@buildstream.apache.org pullrequests: commits@buildstream.apache.org # # Configure github # github: description: "BuildStream plugins" homepage: https://buildstream.build/ # Main features features: # Enable wiki for documentation wiki: true # Enable issue management issues: true # Enable projects for project management boards projects: true # Buttons enabled_merge_buttons: # Disable squash button: squash: false # enable merge button: merge: true # disable rebase button: rebase: false # Close branches when pull requests are merged del_branch_on_merge: true # Enable pages publishing ghp_branch: gh-pages ghp_path: /docs ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/COMMITTERS.rst0000644000175100017510000000250615152545021017073 0ustar00juergjuerg.. _committers: Committers ========== Full commit access ------------------- List of people with full commit access, i.e. blanket commit access to the BuildStream plugins codebase. Note that this is not a full list of all contributors. +-----------------------------------+-----------------------------------+ | Full Name | GitHub User | +===================================+===================================+ | Tristan Van Berkom | gtristan | +-----------------------------------+-----------------------------------+ | Jürg Billeter | juergbi | +-----------------------------------+-----------------------------------+ | Chandan Singh | cs-shadow | +-----------------------------------+-----------------------------------+ | Benjamin Schubert | BenjaminSchubert | +-----------------------------------+-----------------------------------+ | Abderrahim Kitouni | abderrahim | +-----------------------------------+-----------------------------------+ | Sander Striker | sstriker | +-----------------------------------+-----------------------------------+ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/LICENSE0000644000175100017510000002613615152545021015665 0ustar00juergjuerg Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/MANIFEST.in0000644000175100017510000000023015152545021016401 0ustar00juergjuergglobal-include *.yaml include requirements/* include project.conf include COMMITTERS.rst include LICENSE include NOTICE include NEWS include README.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/NEWS0000644000175100017510000000714015152545021015351 0ustar00juergjuerg========================= buildstream-plugins 2.7.0 ========================= o cargo: Support source provenance (#98) o Fix multiple issues in the Docker source plugin (#96) o Support Python 3.14 and drop support for Python 3.9 (#94, #97) ========================= buildstream-plugins 2.5.0 ========================= o Drop support for python 3.8 and add support for python 3.13 (#84) o Implement Source.collect_source_info() or SourceFetcher.get_source_info() on all source plugins (#87) ========================= buildstream-plugins 2.4.0 ========================= o docker: Support storing ref in project.refs (#66) o simple_mirror: Added SourceMirror plugin supporting enhanced URL formatting (#80) o gitlab_lfs_mirror: Added SourceMirror intended for use with GitLab LFS repos (#80) o Enhanced testing and CI enhancements (#78) o Resurrecting CI (#81) ========================= buildstream-plugins 2.3.0 ========================= o pip: support Python 3.12 and future versions (#67) o cargo, docker: Check tar member paths (#69) o git: add tagger to annotated tags (fix for recent git versions) (#73) ========================= buildstream-plugins 2.2.0 ========================= o cargo: Fix mirroring (#55) o cargo: Support authentication using .netrc (#57) o docker: Fix authentication when using .netrc (#59) o docker: Improve flexibility for mirroring (#58) o cargo: Add support for source mirrors and bearer http authentication (#60, #64) ========================= buildstream-plugins 2.1.0 ========================= o Guard against malformed URIs in cargo crates (#52) ========================= buildstream-plugins 2.0.1 ========================= o docker source: Fix "architecture" and "os" configuration options o Updating some package metadata/links o Support Python 3.11 ========================= buildstream-plugins 2.0.0 ========================= No changes in 2.0.0 over 1.95.7 ========================== buildstream-plugins 1.95.7 ========================== o meson: Use `meson install` and rename JOBS environment variable (#41) o meson, cmake: Ensure verbosity (#42) ========================== buildstream-plugins 1.95.6 ========================== o Removed some deprecated variables from plugins (#34) o Avoid deprecation warnings in meson (#38) ========================== buildstream-plugins 1.95.5 ========================== o Updating copyright year in NOTICE file o Updating setup.py with updated author and documentaiton link o Updating generated documentation to use new author and copyright ========================== buildstream-plugins 1.95.4 ========================== o Fixing license headers in source files and ensuring that LICENSE / NOTICE are included in source distributions ========================== buildstream-plugins 1.95.3 ========================== o Revert the convenience build-dir attempt for autotools (#29) o Fix new linting errors o Manage release version in one place (#33) ========================== buildstream-plugins 1.95.1 ========================== o Fixing documentation generation o Updating pylint and correcting errors o Port cargo plugin to use tomli, this will remove the toml dependency as tomli will soon be part of the standard library o Some fixes to the cargo plugin o Update Source.set_ref() implementations according to last minute API correction o Fixed publishing of documentation o Some enhancements to the variables used in the autotools plugin ========================== buildstream-plugins 1.95.0 ========================== Initial beta release of buildstream-plugins. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/NOTICE0000644000175100017510000000024715152545021015557 0ustar00juergjuergApache BuildStream Copyright 2022 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7177758 buildstream_plugins-2.7.0/PKG-INFO0000644000175100017510000000366515152545044015764 0ustar00juergjuergMetadata-Version: 2.4 Name: buildstream-plugins Version: 2.7.0 Summary: A collection of plugins for BuildStream. Home-page: https://buildstream.build Author: The Apache Software Foundation Author-email: dev@buildstream.apache.org License: Apache License Version 2.0 Project-URL: Documentation, https://apache.github.io/buildstream-plugins/ Project-URL: Source, https://github.com/apache/buildstream-plugins/ Project-URL: Tracker, https://github.com/apache/buildstream-plugins/issues Project-URL: Mailing List, https://lists.apache.org/list.html?dev@buildstream.apache.org Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: POSIX Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Programming Language :: Python :: 3.14 Classifier: Topic :: Software Development :: Build Tools Description-Content-Type: text/x-rst; charset=UTF-8 License-File: LICENSE License-File: NOTICE Provides-Extra: cargo Requires-Dist: tomli; python_version < "3.11" and extra == "cargo" Dynamic: author Dynamic: author-email Dynamic: classifier Dynamic: description Dynamic: description-content-type Dynamic: home-page Dynamic: license Dynamic: license-file Dynamic: project-url Dynamic: provides-extra Dynamic: summary BuildStream Plugins =================== A collection of plugins for the `BuildStream `_ project. How to use plugins ------------------ Plugins must be declared by your BuildStream project.conf for use in your project. For instructions on how to load plugins in your BuildStream project, please consult the `plugin loading documentation `_ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/README.rst0000644000175100017510000000067315152545021016345 0ustar00juergjuergBuildStream Plugins =================== A collection of plugins for the `BuildStream `_ project. How to use plugins ------------------ Plugins must be declared by your BuildStream project.conf for use in your project. For instructions on how to load plugins in your BuildStream project, please consult the `plugin loading documentation `_ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/project.conf0000644000175100017510000000212215152545021017162 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # # This project.conf exposes the plugins as a buildstream project so # that plugins can be loaded via junctions. # name: buildstream-plugins min-version: 2.5 plugins: - origin: local path: src/buildstream_plugins/elements elements: - autotools - cmake - make - meson - pip - setuptools - origin: local path: src/buildstream_plugins/sources sources: - bzr - cargo - docker - git - patch - pip - origin: local path: src/buildstream_plugins/sourcemirrors source-mirrors: - gitlab_lfs_mirror - simple_mirror ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/pyproject.toml0000644000175100017510000000173515152545021017572 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # [build-system] requires = [ # We need at least version 36.6.0 that introduced "build_meta" "setuptools>=36.6.0", # In order to build wheels, and as required by PEP 517 "wheel", "Cython" ] build-backend = "setuptools.build_meta" [tool.black] line-length = 119 exclude = ''' ( /( \.eggs | \.git | \.mypy_cache | \.tox | _build | build | dist )/ | src/buildstream/_protos ) ''' ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7135124 buildstream_plugins-2.7.0/requirements/0000755000175100017510000000000015152545044017400 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/requirements/mypy-requirements.txt0000644000175100017510000000011715152545021023652 0ustar00juergjuerg# Additional requirements for running mypy # For docker plugin types-requests ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/requirements/plugin-requirements.txt0000644000175100017510000000026115152545021024152 0ustar00juergjuerg# The dependencies listed here are necessary for specifc plugins, but # aren't required for buildstream-plugins to be installed. # Cargo source tomli # Docker source requests ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/requirements/test-requirements.txt0000644000175100017510000000026715152545021023641 0ustar00juergjuergbuild pytest-env # Provide option to run tests in parallel, less reliable pytest-xdist pytest >= 6.0.1 pytest-datafiles >= 3.0 pylint pycodestyle pyftpdlib responses setuptools wheel ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7182808 buildstream_plugins-2.7.0/setup.cfg0000644000175100017510000000072215152545044016477 0ustar00juergjuerg[aliases] test = pytest [tool:pytest] addopts = --verbose --basetemp ./tmp --durations=20 testpaths = tests norecursedirs = tests/sources/pip-build integration-cache tmp __pycache__ .eggs python_files = tests/*.py markers = integration: run test only if --integration option is specified datafiles: share datafiles in tests env = D:BST_TEST_SUITE=True [mypy] files = src warn_unused_configs = True warn_no_return = True [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/setup.py0000755000175100017510000001031715152545021016367 0ustar00juergjuerg#!/usr/bin/env python3 # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import os import sys try: from setuptools import setup, find_packages except ImportError: print( "BuildStream requires setuptools in order to locate plugins. Install " "it using your package manager (usually python3-setuptools) or via " "pip (pip3 install setuptools)." ) sys.exit(1) ############################################################################### # Parse README # ############################################################################### with open( os.path.join(os.path.dirname(os.path.realpath(__file__)), "README.rst"), encoding="utf-8", ) as readme: long_description = readme.read() ############################################################################### # Load the version # ############################################################################### sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src")) from buildstream_plugins import __version__ # pylint: disable=wrong-import-position setup( name="buildstream-plugins", version=__version__, author="The Apache Software Foundation", author_email="dev@buildstream.apache.org", classifiers=[ "Environment :: Console", "Intended Audience :: Developers", "License :: OSI Approved :: Apache Software License", "Operating System :: POSIX", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "Topic :: Software Development :: Build Tools", ], description="A collection of plugins for BuildStream.", long_description=long_description, long_description_content_type="text/x-rst; charset=UTF-8", license="Apache License Version 2.0", url="https://buildstream.build", project_urls={ "Documentation": "https://apache.github.io/buildstream-plugins/", "Source": "https://github.com/apache/buildstream-plugins/", "Tracker": "https://github.com/apache/buildstream-plugins/issues", "Mailing List": "https://lists.apache.org/list.html?dev@buildstream.apache.org", }, package_dir={"": "src"}, packages=find_packages(where="src"), include_package_data=True, entry_points={ "buildstream.plugins.elements": [ "autotools = buildstream_plugins.elements.autotools", "cmake = buildstream_plugins.elements.cmake", "make = buildstream_plugins.elements.make", "meson = buildstream_plugins.elements.meson", "pip = buildstream_plugins.elements.pip", "setuptools = buildstream_plugins.elements.setuptools", ], "buildstream.plugins.sources": [ "bzr = buildstream_plugins.sources.bzr", "cargo = buildstream_plugins.sources.cargo", "docker = buildstream_plugins.sources.docker", "git = buildstream_plugins.sources.git", "patch = buildstream_plugins.sources.patch", "pip = buildstream_plugins.sources.pip", "zip = buildstream_plugins.sources.zip", ], "buildstream.plugins.sourcemirrors": [ "gitlab_lfs_mirror = buildstream_plugins.sourcemirrors.gitlab_lfs_mirror", "simple_mirror = buildstream_plugins.sourcemirrors.simple_mirror", ], }, extras_require={ "cargo": ['tomli; python_version < "3.11"'], }, zip_safe=False, ) # eof setup() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7109272 buildstream_plugins-2.7.0/src/0000755000175100017510000000000015152545044015444 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7136152 buildstream_plugins-2.7.0/src/buildstream_plugins/0000755000175100017510000000000015152545044021520 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/__init__.py0000644000175100017510000000121115152545021023617 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # # Remember to adjust this version number before tagging releases # __version__ = "2.7.0" ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7158177 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/0000755000175100017510000000000015152545044023334 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/__init__.py0000644000175100017510000000000015152545021025426 0ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/autotools.py0000644000175100017510000000437115152545021025737 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Tristan Van Berkom # # This plugin was originally developped in the https://github.com/apache/buildstream/ # repository and was copied from 1a3c707a6c46573ab159de64ac9cd92e7f6027e6 # """ autotools - Autotools build element =================================== This is a :mod:`BuildElement ` implementation for using Autotools build scripts (also known as the `GNU Build System `_). You will often want to pass additional arguments to ``configure``. This should be done on a per-element basis by setting the ``conf-local`` variable. Here is an example: .. code:: yaml variables: conf-local: | --disable-foo --enable-bar If you want to pass extra options to ``configure`` for every element in your project, set the ``conf-global`` variable in your project.conf file. Here is an example of that: .. code:: yaml elements: autotools: variables: conf-global: | --disable-gtk-doc --disable-static Here is the default configuration for the ``autotools`` element in full: .. literalinclude:: ../../../src/buildstream_plugins/elements/autotools.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the 'autotools' kind. class AutotoolsElement(BuildElement): # pylint: disable=attribute-defined-outside-init BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return AutotoolsElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/autotools.yaml0000644000175100017510000000713315152545021026250 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Autotools default configurations variables: autogen: | export NOCONFIGURE=1; if [ -x %{conf-cmd} ]; then true; elif [ -x %{conf-root}/autogen ]; then %{conf-root}/autogen; elif [ -x %{conf-root}/autogen.sh ]; then %{conf-root}/autogen.sh; elif [ -x %{conf-root}/bootstrap ]; then %{conf-root}/bootstrap; elif [ -x %{conf-root}/bootstrap.sh ]; then %{conf-root}/bootstrap.sh; else autoreconf -ivf %{conf-root}; fi # Project-wide extra arguments to be passed to `configure` conf-global: '' # Element-specific extra arguments to be passed to `configure`. conf-local: '' conf-cmd: "%{conf-root}/configure" conf-args: | --prefix=%{prefix} \ --exec-prefix=%{exec_prefix} \ --bindir=%{bindir} \ --sbindir=%{sbindir} \ --sysconfdir=%{sysconfdir} \ --datadir=%{datadir} \ --includedir=%{includedir} \ --libdir=%{libdir} \ --libexecdir=%{libexecdir} \ --localstatedir=%{localstatedir} \ --sharedstatedir=%{sharedstatedir} \ --mandir=%{mandir} \ --infodir=%{infodir} %{conf-global} %{conf-local} configure: | %{conf-cmd} %{conf-args} make-args: "" make-install-args: >- %{make-args} DESTDIR="%{install-root}" install make: make %{make-args} make-install: make -j1 %{make-install-args} # Set this if the sources cannot handle parallelization. # # notparallel: True # Automatically remove libtool archive files # # Set remove-libtool-modules to "true" to remove .la files for # modules intended to be opened with lt_dlopen() # # Set remove-libtool-libraries to "true" to remove .la files for # libraries # # Value must be "true" or "false" remove-libtool-modules: "false" remove-libtool-libraries: "false" delete-libtool-archives: | if %{remove-libtool-modules} || %{remove-libtool-libraries}; then find "%{install-root}" -name "*.la" -print0 | while read -d '' -r file; do if grep '^shouldnotlink=yes$' "${file}" &>/dev/null; then if %{remove-libtool-modules}; then echo "Removing ${file}." rm "${file}" else echo "Not removing ${file}." fi else if %{remove-libtool-libraries}; then echo "Removing ${file}." rm "${file}" else echo "Not removing ${file}." fi fi done fi config: # Commands for configuring the software # configure-commands: - | %{autogen} - | %{configure} # Commands for building the software # build-commands: - | %{make} # Commands for installing the software into a # destination folder # install-commands: - | %{make-install} - | %{delete-libtool-archives} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} # Use max-jobs CPUs for building and enable verbosity environment: MAKEFLAGS: -j%{max-jobs} V: 1 # And dont consider MAKEFLAGS or V as something which may # affect build output. environment-nocache: - MAKEFLAGS - V ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/cmake.py0000644000175100017510000000432315152545021024763 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Tristan Van Berkom # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ cmake - CMake build element =========================== This is a `BuildElement `_ implementation for using the `CMake `_ build system. You will often want to pass additional arguments to the ``cmake`` program for specific configuration options. This should be done on a per-element basis by setting the ``cmake-local`` variable. Here is an example: .. code:: yaml variables: cmake-local: | -DCMAKE_BUILD_TYPE=Debug If you want to pass extra options to ``cmake`` for every element in your project, set the ``cmake-global`` variable in your project.conf file. Here is an example of that: .. code:: yaml elements: cmake: variables: cmake-global: | -DCMAKE_BUILD_TYPE=Release Here is the default configuration for the ``cmake`` element in full: .. literalinclude:: ../../../src/buildstream_plugins/elements/cmake.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the 'cmake' kind. class CMakeElement(BuildElement): BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return CMakeElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/cmake.yaml0000644000175100017510000000360715152545021025301 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # CMake default configuration variables: build-dir: _builddir # Project-wide extra arguments to be passed to `cmake` cmake-global: '' # Element-specific extra arguments to be passed to `cmake`. cmake-local: '' # The cmake generator to use generator: Ninja cmake-args: | -DCMAKE_VERBOSE_MAKEFILE=ON \ -DCMAKE_INSTALL_PREFIX:PATH="%{prefix}" \ -DCMAKE_INSTALL_LIBDIR:PATH="%{lib}" %{cmake-global} %{cmake-local} cmake: | cmake -B%{build-dir} -H"%{conf-root}" -G"%{generator}" %{cmake-args} make: cmake --build %{build-dir} -- ${JOBS} make-install: env DESTDIR="%{install-root}" cmake --build %{build-dir} --target install # Set this if the sources cannot handle parallelization. # # notparallel: True config: # Commands for configuring the software # configure-commands: - | %{cmake} # Commands for building the software # build-commands: - | %{make} # Commands for installing the software into a # destination folder # install-commands: - | %{make-install} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} # Use max-jobs CPUs for building and enable verbosity environment: JOBS: -j%{max-jobs} # And dont consider JOBS as something which may # affect build output. environment-nocache: - JOBS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/make.py0000644000175100017510000000311615152545021024617 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Ed Baunton # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ make - Make build element ========================= This is a `BuildElement `_ implementation for using GNU make based build. Here is the default configuration for the ``make`` element in full: .. literalinclude:: ../../../src/buildstream_plugins/elements/make.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the 'make' kind. class MakeElement(BuildElement): BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return MakeElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/make.yaml0000644000175100017510000000263615152545021025137 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # make default configurations variables: make-args: >- PREFIX="%{prefix}" make-install-args: >- %{make-args} DESTDIR="%{install-root}" install make: make %{make-args} make-install: make -j1 %{make-install-args} # Set this if the sources cannot handle parallelization. # # notparallel: True config: # Commands for building the software # build-commands: - | %{make} # Commands for installing the software into a # destination folder # install-commands: - | %{make-install} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} # Use max-jobs CPUs for building and enable verbosity environment: MAKEFLAGS: -j%{max-jobs} V: 1 # And dont consider MAKEFLAGS or V as something which may # affect build output. environment-nocache: - MAKEFLAGS - V ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/meson.py0000644000175100017510000000410215152545021025017 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ meson - Meson build element =========================== This is a `BuildElement `_ implementation for using `Meson `_ build scripts. You will often want to pass additional arguments to ``meson``. This should be done on a per-element basis by setting the ``meson-local`` variable. Here is an example: .. code:: yaml variables: meson-local: | -Dmonkeys=yes If you want to pass extra options to ``meson`` for every element in your project, set the ``meson-global`` variable in your project.conf file. Here is an example of that: .. code:: yaml elements: meson: variables: meson-global: | -Dmonkeys=always Here is the default configuration for the ``meson`` element in full: .. literalinclude:: ../../../src/buildstream_plugins/elements/meson.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the 'meson' kind. class MesonElement(BuildElement): BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return MesonElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/meson.yaml0000644000175100017510000000406215152545021025336 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Meson default configuration variables: build-dir: _builddir # Project-wide extra arguments to be passed to `meson` meson-global: '' # Element-specific extra arguments to be passed to `meson`. meson-local: '' meson-args: | --prefix=%{prefix} \ --bindir=%{bindir} \ --sbindir=%{sbindir} \ --sysconfdir=%{sysconfdir} \ --datadir=%{datadir} \ --includedir=%{includedir} \ --libdir=%{libdir} \ --libexecdir=%{libexecdir} \ --localstatedir=%{localstatedir} \ --sharedstatedir=%{sharedstatedir} \ --mandir=%{mandir} \ --infodir=%{infodir} %{meson-global} %{meson-local} meson: meson setup %{conf-root} %{build-dir} %{meson-args} meson-build: | ninja -v -j ${JOBS} -C %{build-dir} meson-install: | env DESTDIR="%{install-root}" meson install -C %{build-dir} --no-rebuild # Set this if the sources cannot handle parallelization. # # notparallel: True config: # Commands for configuring the software # configure-commands: - | %{meson} # Commands for building the software # build-commands: - | %{meson-build} # Commands for installing the software into a # destination folder # install-commands: - | %{meson-install} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} # Use max-jobs CPUs for building environment: JOBS: | %{max-jobs} # And dont consider JOBS as something which may # affect build output. environment-nocache: - JOBS ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/pip.py0000644000175100017510000000303615152545021024473 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Mathieu Bridon # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ pip - Pip build element ======================= A `BuildElement `_ implementation for installing Python modules with pip The pip default configuration: .. literalinclude:: ../../../src/buildstream_plugins/elements/pip.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the 'pip' kind. class PipElement(BuildElement): BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return PipElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/pip.yaml0000644000175100017510000000234715152545021025011 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Pip default configurations variables: pip: pip pip-flags: | %{pip} install --no-deps --root=%{install-root} --prefix=%{prefix} pip-install-package: | %{pip-flags} %{conf-root} pip-download-dir: | .bst_pip_downloads pip-install-dependencies: | if [ -e %{pip-download-dir} ]; then %{pip-flags} %{pip-download-dir}/*; fi config: configure-commands: [] build-commands: [] # Commands for installing the software into a # destination folder # install-commands: - | %{pip-install-package} - | %{pip-install-dependencies} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/setuptools.py0000644000175100017510000000321315152545021026121 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Tristan Van Berkom # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository (previously named 'distutils') and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ setuptools - Python setuptools element ====================================== A `BuildElement `_ implementation for using python setuptools The setuptools default configuration: .. literalinclude:: ../../../src/buildstream_plugins/elements/setuptools.yaml :language: yaml See `built-in functionality documentation `_ for details on common configuration options for build elements. """ from buildstream import BuildElement # Element implementation for the python 'setuptools' kind. class SetuptoolsElement(BuildElement): BST_MIN_VERSION = "2.0" # Plugin entry point def setup(): return SetuptoolsElement ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/elements/setuptools.yaml0000644000175100017510000000252315152545021026436 0ustar00juergjuerg# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Default python distutils configuration variables: # When building for python2 distutils, simply # override this in the element declaration python: python3 python-build: | %{python} %{conf-root}/setup.py build install-args: | --prefix "%{prefix}" \ --root "%{install-root}" python-install: | %{python} %{conf-root}/setup.py install %{install-args} config: # Commands for configuring the software # configure-commands: [] # Commands for building the software # build-commands: - | %{python-build} # Commands for installing the software into a # destination folder # install-commands: - | %{python-install} # Commands for stripping debugging information out of # installed binaries # strip-commands: - | %{strip-binaries} ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7161305 buildstream_plugins-2.7.0/src/buildstream_plugins/sourcemirrors/0000755000175100017510000000000015152545044024436 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sourcemirrors/__init__.py0000644000175100017510000000000015152545021026530 0ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sourcemirrors/gitlab_lfs_mirror.py0000644000175100017510000000535715152545021030515 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ gitlab_lfs_mirror - plugin for accessing files stored in git-lfs on GitLab ========================================================================== .. note:: The ``gitlab_lfs_mirror`` plugin is available *Since 2.4.0* If you store files in a git-lfs repository on gitlab.com, you can access them using a URL like https://gitlab.com/path/to/repo/-/raw/master/path/to/file which you can then use as a mirror for buildstream. However this only works for public repositories. For internal (on self-hosted GitLab instances) and private repositories, the above doesn't work since buildstream cannot authenticate with the GitLab web UI. This plugin solves this by going through the GitLab REST API. You need an access token that access the Repository Files API (i.e. with read_api or read_repository scope). As of this writing, the GitLab CI/CD job token doesn't allow access to this API endpoint, so you need a dedicated access token. **Usage:** .. code:: yaml - name: my-mirror kind: gitlab_lfs_mirror config: url: https://gitlab.example.com/ project: mirrors/{alias} ref: main # optional, defaults to master aliases: - my-alias - another-alias """ from posixpath import join from urllib.parse import quote from buildstream import SourceMirror class GitlabLFSMirror(SourceMirror): BST_MIN_VERSION = "2.2" def configure(self, node): node.validate_keys(["aliases", "url", "project", "ref"]) self.set_supported_aliases(node.get_str_list("aliases")) self.url = node.get_str("url") self.project = node.get_str("project") self.ref = node.get_str("ref", "master") def translate_url(self, *, alias, alias_url, source_url, extra_data): project_id = quote(self.project.format(alias=alias), safe="") filename = quote(source_url, safe="") translated_url = join( self.url, "api/v4/projects", project_id, "repository/files", filename, f"raw?ref={self.ref}&lfs=true", ) if extra_data is not None: extra_data["http-auth"] = "bearer" return translated_url def setup(): return GitlabLFSMirror ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sourcemirrors/simple_mirror.py0000644000175100017510000000315515152545021027672 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ simple_mirror - plugin for simplifying mirror definitions ========================================================= .. note:: The ``simple_mirror`` plugin is available *Since 2.4.0* **Usage:** .. code:: yaml - name: my-mirror kind: simple_mirror config: url: https://example.com/mirrors/{alias}/ aliases: - my-alias - another-alias This plugin simplifies defining mirrors for projects where the mirrors follow a predictable URL format that only varies with the alias name. """ from posixpath import join from buildstream import SourceMirror class SimpleMirror(SourceMirror): BST_MIN_VERSION = "2.2" def configure(self, node): node.validate_keys(["url", "aliases"]) self.set_supported_aliases(node.get_str_list("aliases")) self.url = node.get_str("url") def translate_url(self, *, alias, alias_url, source_url, extra_data): base_url = self.url.format(alias=alias) translated_url = join(base_url, source_url) return translated_url def setup(): return SimpleMirror ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7170465 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/0000755000175100017510000000000015152545044023203 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/__init__.py0000644000175100017510000000000015152545021025275 0ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/_utils.py0000644000175100017510000001024515152545021025051 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Mostly copied from downloadablefilesource.py in buildstream. # import contextlib import shutil import os import netrc import urllib.parse import urllib.request import urllib.error class _NetrcPasswordManager: def __init__(self, netrc_config): self.netrc = netrc_config def add_password(self, realm, uri, user, passwd): pass def find_user_password(self, realm, authuri): if not self.netrc: return None, None parts = urllib.parse.urlsplit(authuri) entry = self.netrc.authenticators(parts.hostname) if not entry: return None, None else: login, _, password = entry return login, password def _parse_netrc(): netrc_config = None try: netrc_config = netrc.netrc() except (OSError, netrc.NetrcParseError): # If the .netrc file was not found, FileNotFoundError will be # raised, but OSError will be raised directly by the netrc package # in the case that $HOME is not set. # # This will catch both cases. pass return netrc_config class _UrlOpenerCreator: def __init__(self, netrc_config): self.netrc_config = netrc_config def get_url_opener(self, bearer_auth): if self.netrc_config and not bearer_auth: netrc_pw_mgr = _NetrcPasswordManager(self.netrc_config) http_auth = urllib.request.HTTPBasicAuthHandler(netrc_pw_mgr) return urllib.request.build_opener(http_auth) return urllib.request.build_opener() def download_file(url, etag, directory, auth_scheme): opener_creator = _UrlOpenerCreator(_parse_netrc()) opener = opener_creator.get_url_opener(auth_scheme == "bearer") default_name = os.path.basename(url) request = urllib.request.Request(url) request.add_header("Accept", "*/*") request.add_header("User-Agent", "BuildStream/2") if opener_creator.netrc_config and auth_scheme == "bearer": parts = urllib.parse.urlsplit(url) entry = opener_creator.netrc_config.authenticators(parts.hostname) if entry: _, _, password = entry auth_header = "Bearer " + password request.add_header("Authorization", auth_header) if etag is not None: request.add_header("If-None-Match", etag) try: with contextlib.closing(opener.open(request)) as response: info = response.info() # some servers don't honor the 'If-None-Match' header if etag and info["ETag"] == etag: return None, None, None etag = info["ETag"] length = info.get("Content-Length") filename = info.get_filename(default_name) filename = os.path.basename(filename) local_file = os.path.join(directory, filename) with open(local_file, "wb") as dest: shutil.copyfileobj(response, dest) actual_length = dest.tell() if length and actual_length < int(length): raise ValueError(f"Partial file {actual_length}/{length}") except urllib.error.HTTPError as e: if e.code == 304: # 304 Not Modified. # Because we use etag only for matching ref, currently specified ref is what # we would have downloaded. return None, None, None return None, None, str(e) except (urllib.error.URLError, OSError, ValueError) as e: # Note that urllib.request.Request in the try block may throw a # ValueError for unknown url types, so we handle it here. return None, None, str(e) return local_file, etag, None ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/bzr.py0000644000175100017510000002412115152545021024345 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Jonathan Maw # # This plugin was originally developped in the https://github.com/apache/buildstream/ # repository and was copied from 1a3c707a6c46573ab159de64ac9cd92e7f6027e6 # """ bzr - stage files from a bazaar repository ========================================== **Host dependencies:** * bzr **Usage:** .. code:: yaml # Specify the bzr source kind kind: bzr # Specify the bzr url. Bazaar URLs come in many forms, see # `bzr help urlspec` for more information. Using an alias defined # in your project configuration is encouraged. url: https://launchpad.net/bzr # Specify the tracking branch. This is mandatory, as bzr cannot identify # an individual revision outside its branch. bzr URLs that omit the branch # name implicitly specify the trunk branch, but bst requires this to be # explicit. track: trunk # Specify the ref. This is a revision number. This is usually a decimal, # but revisions on a branch are of the form # .. # e.g. 6622.1.6. # The ref must be specified to build, and 'bst source track' will update the # revision number to the one on the tip of the branch specified in 'track'. ref: 6622 # Specify the version to be reported as the *guess_version* when reporting # SourceInfo # # Since 2.5 # version: 1.2 See `built-in functionality doumentation `_ for details on common configuration options for sources. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The bzr source reports the URL of the bzr repository as the *url*. Further, the bzr source reports the `SourceInfoMedium.BZR `_ *medium* and the` `SourceVersionType.COMMIT `_ *version_type*, for which it reports the bzr revision number as the *version*. Since the bzr source does not have a way to know what the release version corresponds to the revision number, the bzr source exposes the ``version`` configuration attribute to allow explicit specification of the *guess_version*. """ import os import shutil import fcntl from contextlib import contextmanager from buildstream import Source, SourceError from buildstream import utils # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass class BzrSource(Source): # pylint: disable=attribute-defined-outside-init BST_MIN_VERSION = "2.5" def configure(self, node): node.validate_keys(["url", "track", "ref", "version", *Source.COMMON_CONFIG_KEYS]) self.original_url = node.get_str("url") self.tracking = node.get_str("track") self.ref = node.get_str("ref", None) self.url = self.translate_url(self.original_url) self.version = node.get_str("version", None) def preflight(self): # Check if bzr is installed, get the binary at the same time. self.host_bzr = utils.get_host_tool("bzr") def get_unique_key(self): unique_key = [self.original_url, self.tracking, self.ref] # Backwards compatible method of supporting configuration # attributes which affect SourceInfo generation. if self.version is not None: unique_key.append(self.version) return unique_key def is_cached(self): with self._locked(): return self._check_ref() def load_ref(self, node): self.ref = node.get_str("ref", None) def get_ref(self): return self.ref def set_ref(self, ref, node): node["ref"] = self.ref = ref def track(self): # pylint: disable=arguments-differ with self.timed_activity("Tracking {}".format(self.url), silent_nested=True), self._locked(): self._ensure_mirror(skip_ref_check=True) ret, out = self.check_output( [ self.host_bzr, "version-info", "--custom", "--template={revno}", self._get_branch_dir(), ], fail="Failed to read the revision number at '{}'".format(self._get_branch_dir()), ) if ret != 0: raise SourceError("{}: Failed to get ref for tracking {}".format(self, self.tracking)) return out def fetch(self): # pylint: disable=arguments-differ with self.timed_activity("Fetching {}".format(self.url), silent_nested=True), self._locked(): self._ensure_mirror() def stage(self, directory): self.call( [ self.host_bzr, "checkout", "--lightweight", "--revision=revno:{}".format(self.ref), self._get_branch_dir(), directory, ], fail="Failed to checkout revision {} from branch {} to {}".format( self.ref, self._get_branch_dir(), directory ), ) # Remove .bzr dir shutil.rmtree(os.path.join(directory, ".bzr")) def init_workspace(self, directory): url = os.path.join(self.url, self.tracking) with self.timed_activity('Setting up workspace "{}"'.format(directory), silent_nested=True): # Checkout from the cache self.call( [ self.host_bzr, "branch", "--use-existing-dir", "--revision=revno:{}".format(self.ref), self._get_branch_dir(), directory, ], fail="Failed to branch revision {} from branch {} to {}".format( self.ref, self._get_branch_dir(), directory ), ) # Switch the parent branch to the source's origin self.call( [ self.host_bzr, "switch", "--directory={}".format(directory), url, ], fail="Failed to switch workspace's parent branch to {}".format(url), ) def collect_source_info(self): return [ self.create_source_info( self.url, SourceInfoMedium.BAZAAR, SourceVersionType.COMMIT, self.ref, version_guess=self.version ) ] # _locked() # # This context manager ensures exclusive access to the # bzr repository. # @contextmanager def _locked(self): lockdir = os.path.join(self.get_mirror_directory(), "locks") lockfile = os.path.join(lockdir, utils.url_directory_name(self.original_url) + ".lock") os.makedirs(lockdir, exist_ok=True) with open(lockfile, "wb") as lock: fcntl.flock(lock, fcntl.LOCK_EX) try: yield finally: fcntl.flock(lock, fcntl.LOCK_UN) def _check_ref(self): # If the mirror doesnt exist yet, then we dont have the ref if not os.path.exists(self._get_branch_dir()): return False return ( self.call( [ self.host_bzr, "revno", "--revision=revno:{}".format(self.ref), self._get_branch_dir(), ] ) == 0 ) def _get_branch_dir(self): return os.path.join(self._get_mirror_dir(), self.tracking) def _get_mirror_dir(self): return os.path.join( self.get_mirror_directory(), utils.url_directory_name(self.original_url), ) def _ensure_mirror(self, skip_ref_check=False): mirror_dir = self._get_mirror_dir() bzr_metadata_dir = os.path.join(mirror_dir, ".bzr") if not os.path.exists(bzr_metadata_dir): self.call( [self.host_bzr, "init-repo", "--no-trees", mirror_dir], fail="Failed to initialize bzr repository", ) branch_dir = os.path.join(mirror_dir, self.tracking) branch_url = self.url + "/" + self.tracking if not os.path.exists(branch_dir): # `bzr branch` the branch if it doesn't exist # to get the upstream code self.call( [self.host_bzr, "branch", branch_url, branch_dir], fail="Failed to branch from {} to {}".format(branch_url, branch_dir), ) else: # `bzr pull` the branch if it does exist # to get any changes to the upstream code self.call( [ self.host_bzr, "pull", "--directory={}".format(branch_dir), branch_url, ], fail="Failed to pull new changes for {}".format(branch_dir), ) if not skip_ref_check and not self._check_ref(): raise SourceError( "Failed to ensure ref '{}' was mirrored".format(self.ref), reason="ref-not-mirrored", ) def setup(): return BzrSource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/cargo.py0000644000175100017510000004615315152545021024654 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Tristan Van Berkom # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-experimental/ # repository and was copied from a60426126e5bec2d630fcd889a9f5af13af00ea6 # """ cargo - Automatically stage crate dependencies ============================================== A convenience Source element for vendoring rust project dependencies. Placing this source in the source list, after a source which stages a Cargo.lock file, will allow this source to read the Cargo.lock file and obtain the crates automatically into %{vendordir}. Set the `ref` field to an empty list like so: `ref: []`, and then run `bst source track path_to_bst_file.bst`. **Usage:** .. code:: yaml # Specify the cargo source kind kind: cargo # Url of the crates repository to download from (default: https://static.crates.io/crates) url: https://static.crates.io/crates # Internal source reference, this is a list of dictionaries # which store the crate names and versions. # # This will be automatically updated with `bst source track` ref: - name: packagename version: 1.2.1 - name: packagename version: 1.3.0 # Specify a directory for the vendored crates (defaults to ./crates) vendor-dir: crates # Optionally specify the name of the lock file to use (defaults to Cargo.lock) cargo-lock: Cargo.lock See `built-in functionality doumentation `_ for details on common configuration options for sources. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The cargo source reports the URL of the archive crates as the *url* for each crate. Further, the cargo source reports the `SourceInfoMedium.REMOTE_FILE `_ *medium* and the `SourceVersionType.SHA256 `_ *version_type*, for which it reports the checksum of the archive as the *version*. The versions extracted from the Cargo.lock at tracking time are used to report the *guess_version*. Additional source info can be specified using the `provenance` field for each referenced crate as per `built-in source provenance documentation `_. """ import json import os.path import tarfile # We prefer tomli that was put into standard library as tomllib # starting from 3.11 try: import tomllib # type: ignore except ImportError: import tomli as tomllib # type: ignore from buildstream import Source, SourceFetcher, SourceError from buildstream import utils from ._utils import download_file # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass # This automatically goes into .cargo/config # _default_vendor_config_template = ( "[source.crates-io]\n" + 'registry = "{vendorurl}"\n' + 'replace-with = "vendored-sources"\n' + "[source.vendored-sources]\n" + 'directory = "{vendordir}"\n' ) # Crate() # # Use a SourceFetcher class to be the per crate helper # # Args: # cargo (Cargo): The main Source implementation # name (str): The name of the crate to depend on # version (str): The version of the crate to depend on # sha (str|None): The sha256 checksum of the downloaded crate # class Crate(SourceFetcher): def __init__(self, cargo, name, version, sha=None, provenance=None): super().__init__() self.cargo = cargo self.name = name self.version = str(version) self.sha = sha self.provenance = provenance self.mark_download_url(cargo.url) ######################################################## # SourceFetcher API method implementations # ######################################################## def fetch(self, alias_override=None, **kwargs): # Just a defensive check, it is impossible for the # file to be already cached because Source.fetch() will # not be called if the source is already cached. # if os.path.isfile(self._get_mirror_file()): return # pragma: nocover # Download the crate crate_url, auth_scheme = self._get_url(alias_override) with self.cargo.timed_activity("Downloading: {}".format(crate_url), silent_nested=True): sha256 = self._download(crate_url, auth_scheme) if self.sha is not None and sha256 != self.sha: raise SourceError( "File downloaded from {} has sha256sum '{}', not '{}'!".format(crate_url, sha256, self.sha) ) def get_source_info(self): url, _ = self._get_url() return self.cargo.create_source_info( url, SourceInfoMedium.REMOTE_FILE, SourceVersionType.SHA256, self.sha, version_guess=self.version, provenance_node=self.provenance, ) ######################################################## # Helper APIs for the Cargo Source to use # ######################################################## # stage() # # A delegate method to do the work for a single crate # in Source.stage(). # # Args: # (directory): The vendor subdirectory to stage to # def stage(self, directory): try: mirror_file = self._get_mirror_file() with tarfile.open(mirror_file) as tar: members = tar.getmembers() if hasattr(tarfile, "tar_filter"): # Python 3.12+ (and older versions with backports) tar.extractall(path=directory, filter="tar") else: for member in members: self._assert_tarinfo_safe(member, directory) tar.extractall(path=directory, members=members) if members: dirname = members[0].name.split("/")[0] package_dir = os.path.join(directory, dirname) checksum_file = os.path.join(package_dir, ".cargo-checksum.json") with open(checksum_file, "w", encoding="utf-8") as f: checksum_data = {"package": self.sha, "files": {}} json.dump(checksum_data, f) except (tarfile.TarError, OSError) as e: raise SourceError("{}: Error staging source: {}".format(self, e)) from e # is_cached() # # Get whether we have a local cached version of the source # # Returns: # (bool): Whether we are cached or not # def is_cached(self): return os.path.isfile(self._get_mirror_file()) # is_resolved() # # Get whether the current crate is resolved # # Returns: # (bool): Whether we have a sha or not # def is_resolved(self): return self.sha is not None ######################################################## # Private helpers # ######################################################## # Assert that a tarfile is safe to extract; specifically, make # sure that we don't do anything outside of the target # directory (this is possible, if, say, someone engineered a # tarfile to contain paths that start with ..). def _assert_tarinfo_safe(self, member: tarfile.TarInfo, target_dir: str): final_path = os.path.abspath(os.path.join(target_dir, member.path)) if not final_path.startswith(target_dir): raise SourceError( "{}: Tarfile attempts to extract outside the staging area: " "{} -> {}".format(self, member.path, final_path) ) if member.islnk(): linked_path = os.path.abspath(os.path.join(target_dir, member.linkname)) if not linked_path.startswith(target_dir): raise SourceError( "{}: Tarfile attempts to hardlink outside the staging area: " "{} -> {}".format(self, member.path, final_path) ) # Don't need to worry about symlinks because they're just # files here and won't be able to do much harm once we are # in a sandbox. # _download() # # Downloads the crate from the url and caches it. # # Args: # url (str): The url to download from # # Returns: # (str): The sha256 checksum of the downloaded crate # def _download(self, url, auth_scheme): # We do not use etag in case what we have in cache is # not matching ref in order to be able to recover from # corrupted download. if self.sha: etag = self._get_etag(self.sha) else: etag = None with self.cargo.tempdir() as td: local_file, etag, error = download_file(url, etag, td, auth_scheme) if error: raise SourceError("{}: Error mirroring {}: {}".format(self, url, error), temporary=True) # Make sure url-specific mirror dir exists. os.makedirs(self._get_mirror_dir(), exist_ok=True) # Store by sha256sum sha256 = utils.sha256sum(local_file) # Even if the file already exists, move the new file over. # In case the old file was corrupted somehow. os.rename(local_file, self._get_mirror_file(sha256)) if etag: self._store_etag(sha256, etag) return sha256 # _get_url() # # Fetches the URL to download this crate from # # Args: # alias (str|None): The URL alias to apply, if any # # Returns: # (str): The URL for this crate # def _get_url(self, alias=None): path = "{name}/{name}-{version}.crate".format(name=self.name, version=self.version) extra_data = {} if utils.get_bst_version() >= (2, 2): translated_url = self.cargo.translate_url( self.cargo.url, suffix=path, alias_override=alias, extra_data=extra_data ) else: translated_url = self.cargo.translate_url(self.cargo.url, alias_override=alias) + path return translated_url, extra_data.get("http-auth") # _get_etag() # # Fetches the locally stored ETag information for this # crate's download. # # Args: # sha (str): The sha256 checksum of the downloaded crate # # Returns: # (str|None): The ETag to use for requests, or None if nothing is # locally downloaded # def _get_etag(self, sha): etagfilename = os.path.join(self._get_mirror_dir(), "{}.etag".format(sha)) if os.path.exists(etagfilename): with open(etagfilename, "r", encoding="utf-8") as etagfile: return etagfile.read() return None # _store_etag() # # Stores the locally cached ETag information for this crate. # # Args: # sha (str): The sha256 checksum of the downloaded crate # etag (str): The ETag to use for requests of this crate # def _store_etag(self, sha, etag): etagfilename = os.path.join(self._get_mirror_dir(), "{}.etag".format(sha)) with utils.save_file_atomic(etagfilename) as etagfile: etagfile.write(etag) # _get_mirror_dir() # # Gets the local mirror directory for this upstream cargo repository # def _get_mirror_dir(self): return os.path.join( self.cargo.get_mirror_directory(), utils.url_directory_name(self.cargo.url), self.name, self.version, ) # _get_mirror_file() # # Gets the local mirror filename for this crate # # Args: # sha (str|None): The sha256 checksum of the downloaded crate # def _get_mirror_file(self, sha=None): return os.path.join(self._get_mirror_dir(), sha or self.sha) class CargoSource(Source): BST_MIN_VERSION = "2.5" # We need the Cargo.lock file to construct our ref at track time BST_REQUIRES_PREVIOUS_SOURCES_TRACK = True BST_CUSTOM_SOURCE_PROVENANCE = True ######################################################## # Plugin/Source API method implementations # ######################################################## def configure(self, node): # The url before any aliasing # self.original_url = node.get_str("url", "https://static.crates.io/crates") self.cargo_lock = node.get_str("cargo-lock", "Cargo.lock") self.vendor_dir = node.get_str("vendor-dir", "crates") self.provenance = {} # Because source provenance info lives in the ref it would be # removed upon source track, create a backup here so it is # available to be added back in when setting the ref ref = node.get_sequence("ref", None) if ref is not None: for crate in ref: if "provenance" in crate: crate_name = crate.get_str("name") provenance = crate.get_mapping("provenance") self.provenance[crate_name] = provenance.strip_node_info() # If the specified URL is just an alias, require the alias to resolve # to a URL with a trailing slash. Otherwise, append a trailing slash if # it's missing, for backward compatibility. self.url = self.original_url if not self.url.endswith(":") and not self.url.endswith("/"): self.url += "/" node.validate_keys(Source.COMMON_CONFIG_KEYS + ["url", "ref", "cargo-lock", "vendor-dir"]) # Needs to be marked here so that `track` can translate it later. self.mark_download_url(self.url) self.load_ref(node) def preflight(self): return def get_unique_key(self): return [self.original_url, self.cargo_lock, self.vendor_dir, self.ref] def is_resolved(self): return (self.ref is not None) and all(crate.is_resolved() for crate in self.crates) def is_cached(self): return all(crate.is_cached() for crate in self.crates) def load_ref(self, node): ref = node.get_sequence("ref", None) self._recompute_crates(ref) def get_ref(self): return self.ref def set_ref(self, ref, node): def add_provenance(crate): if crate["name"] in self.provenance: crate["provenance"] = self.provenance[crate["name"]] return crate # add provenance back in ref = list(map(add_provenance, ref)) node["ref"] = ref self._recompute_crates(node.get_sequence("ref")) def track(self, *, previous_sources_dir): new_ref = [] lockfile = os.path.join(previous_sources_dir, self.cargo_lock) try: with open(lockfile, "rb") as f: try: lock = tomllib.load(f) except tomllib.TOMLDecodeError as e: raise SourceError( "Malformed Cargo.lock file at: {}".format(self.cargo_lock), detail="{}".format(e), ) from e except FileNotFoundError as e: raise SourceError( "Failed to find Cargo.lock file at: {}".format(self.cargo_lock), detail="The cargo plugin expects to find a Cargo.lock file in\n" + "the sources staged before it in the source list, but none was found.", ) from e # FIXME: Better validation would be good here, so we can raise more # useful error messages in the case of a malformed Cargo.lock file. # for package in lock["package"]: if "source" not in package: continue new_ref += [{"name": package["name"], "version": str(package["version"]), "sha": package.get("checksum")}] # Make sure the order we set it at track time is deterministic new_ref = sorted(new_ref, key=lambda c: (c["name"], c["version"])) # Download the crates and get their shas for crate_obj in new_ref: if crate_obj["sha"] is not None: continue crate = Crate(self, crate_obj["name"], crate_obj["version"]) crate_url, auth_scheme = crate._get_url() with self.timed_activity("Downloading: {}".format(crate_url), silent_nested=True): crate_obj["sha"] = crate._download(crate_url, auth_scheme) return new_ref def stage(self, directory): # Stage the crates into the vendor directory vendor_dir = os.path.join(directory, self.vendor_dir) for crate in self.crates: crate.stage(vendor_dir) # Stage our vendor config vendor_config = _default_vendor_config_template.format( vendorurl=self.translate_url(self.url), vendordir=self.vendor_dir ) conf_dir = os.path.join(directory, ".cargo") conf_file = os.path.join(conf_dir, "config") os.makedirs(conf_dir, exist_ok=True) with open(conf_file, "w", encoding="utf-8") as f: f.write(vendor_config) def get_source_fetchers(self): return self.crates ######################################################## # Private helpers # ######################################################## def _recompute_crates(self, ref): self.crates = self._parse_crates(ref) if not self.crates: self.ref = None else: self.ref = [{"name": crate.name, "version": crate.version, "sha": crate.sha} for crate in self.crates] # _parse_crates(): # # Generates a list of crates based on the passed ref # # Args: # (list|None) refs: The list of name/version dictionaries # # Returns: # (list): A list of Crate objects # def _parse_crates(self, refs): # Return an empty list for no ref if refs is None: return [] return [ Crate( self, crate.get_str("name"), crate.get_str("version"), sha=crate.get_str("sha", None), provenance=crate.get_mapping("provenance", None), ) for crate in refs ] def setup(): return CargoSource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/docker.py0000644000175100017510000007152615152545021025032 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Sam Thursfield # Chandan Singh # # This plugin was originally developped in the https://gitlab.com/BuildStream/bst-plugins-container/ # repository and was copied from 192aa75a62161b655b051d5b69f17d9233cf4dfe # """ docker - stage files from Docker images ======================================= **Usage:** .. code:: yaml # Specify the docker source kind kind: docker # Specify the registry endpoint, defaults to Docker Hub (optional) registry-url: https://registry.hub.docker.com # Image path image: library/alpine # Alternatively, you can specify a full url, the registry endpoint # is assumed to be at the root of the domain # url: https://registry.hub.docker.com/library/alpine # Image tag to follow (optional) track: latest # Specify the digest of the exact image to use (required) ref: 6c9f6f68a131ec6381da82f2bff978083ed7f4f7991d931bfa767b7965ebc94b # Some images are built for multiple platforms. When tracking a tag, we # will choose which image to use based on these settings. Default values # are chosen based on the output of `uname -m` and `uname -s`, but you # can override them. # # architecture: arm64 # os: linux # # **Since**: 2.0.1 # Specify the version to be reported as the *guess_version* when reporting # SourceInfo # # Since: 2.5 # version: 1.2 Note that Docker images may contain device nodes. BuildStream elements cannot contain device nodes so those will be dropped. Any regular files in the /dev directory will also be dropped. See `built-in functionality doumentation `_ for details on common configuration options for sources. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The docker source reports the URL of the docker registry as the *url*. Further, the docker source reports the `SourceInfoMedium.OCI_IMAGE `_ *medium* and the `SourceVersionType.OCI_DIGEST `_ *version_type*, for which it reports the content digest of the docker image as the *version*. Additionally, the docker source reports the docker image name through the ``image-name`` key of the *extra_data*. As such, after removing the scheme from the URL (i.e. remove ``https://``) the same docker image can be obtained by calling: .. code:: bash docker pull /@ Since the docker source does not have any way to guess what tag is associated to the digest, or what release version that would mean; the docker source exposes the ``version`` configuration attribute to allow explicit specification of the *guess_version*. """ import hashlib import json import os import platform import shutil import tarfile import urllib.parse from collections import OrderedDict import requests from buildstream import Source, SourceError from buildstream.utils import ( save_file_atomic, sha256sum, link_files, move_atomic, get_umask, ) # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass _DOCKER_HUB_URL = "https://registry.hub.docker.com" def parse_bearer_authorization_challenge(text): # Hand-written and probably broken parsing of the Www-Authenticate # response. I can't find a built-in way to parse this, but I probably # didn't look hard enough. if not text.startswith("Bearer "): raise SourceError("Unexpected Www-Authenticate response: %{}".format(text)) pairs = {} text = text[len("Bearer ") :] for pair in text.split(","): key, value = pair.split("=") pairs[key] = value[1:-1] return pairs def default_architecture(): machine = platform.machine() if machine == "x86_64": return "amd64" elif machine == "aarch64": return "arm64" else: return machine def default_os(): return platform.system().lower() # Variant of urllib.parse.urljoin() allowing multiple path components at once. def urljoin(url, *args): for arg in args: if not url.endswith("/"): url += "/" url = urllib.parse.urljoin(url, arg.lstrip("/")) return url # Handles authentication with a bearer token class BearerAuth(requests.auth.AuthBase): def __init__(self, api_timeout=3): self.token = None self.api_timeout = api_timeout def __call__(self, r): if self.token: r.headers["Authorization"] = "Bearer {}".format(self.token) return r def refresh_token(self, auth_challenge): auth_vars = parse_bearer_authorization_challenge(auth_challenge) # Respond to an Www-Authenticate challenge by requesting the necessary # token from the 'realm' (endpoint) that we were given in the challenge. request_url = "{realm}?service={service}&scope={scope}".format(**auth_vars) response = requests.get(request_url, timeout=self.api_timeout) response.raise_for_status() self.token = response.json()["token"] # DockerManifestError # # Raised if something goes wrong while querying an image manifest from a remote # registry. # class DockerManifestError(SourceError): def __init__(self, message, manifest=None): super().__init__(message) self.manifest = manifest class DockerRegistryV2Client: def __init__(self, endpoint, api_timeout=3): self.endpoint = endpoint self.api_timeout = api_timeout self.auth = BearerAuth(api_timeout) def _request(self, subpath, extra_headers=None, stream=False, _reauthorized=False): if not extra_headers: extra_headers = {} headers = {"content-type": "application/json"} headers.update(extra_headers) url = urljoin(self.endpoint, "v2", subpath) response = requests.get(url, headers=headers, stream=stream, timeout=self.api_timeout, auth=self.auth) if response.status_code == requests.codes["unauthorized"] and not _reauthorized: # This request requires (re)authorization. See: # https://docs.docker.com/registry/spec/auth/token/ auth_challenge = response.headers["Www-Authenticate"] self.auth.refresh_token(auth_challenge) return self._request(subpath, extra_headers=extra_headers, _reauthorized=True) else: response.raise_for_status() return response # digest(): # # Calculate a Docker-compatible digest of an arbitrary string of bytes. # # Args: # content (bytes): Content to hash # # Returns: # (str) A Docker-compatible digest of 'content' @staticmethod def digest(content): digest_hash = hashlib.sha256() digest_hash.update(content) return "sha256:" + digest_hash.hexdigest() # manifest(): # # Fetches the image manifest for a given image from the remote registry. # # If this is a "fat" (multiplatform) image, the 'artitecture' and 'os' # parameters control which of the available images is chosen. # # The manifest is returned verbatim, so you need to parse it yourself # with json.loads() to get at its contents. The verbatim text can be used # to recalculate the content digest, just encode it and pass to .digest(). # If we returned only the parsed JSON data you wouldn't be able to do this. # # Args: # image_path (str): Relative path to the image, e.g. library/alpine # reference (str): Either a tag name (such as 'latest') or the content # digest of an exact version of the image. # architecture (str): Architecture name (amd64, arm64, etc.) # os_ (str): OS name (e.g. linux) # # Raises: # requests.RequestException, if network errors occur # # Returns: # (str, str): A tuple of the manifest content as text, and its content hash def manifest( self, image_path, reference, architecture, os_, ): # pylint: disable=too-many-locals accept_types = [ "application/vnd.docker.distribution.manifest.v2+json", "application/vnd.docker.distribution.manifest.list.v2+json", ] manifest_url = urljoin(image_path, "manifests", urllib.parse.quote(reference)) response = self._request(manifest_url, extra_headers={"Accept": ",".join(accept_types)}) try: manifest = json.loads(response.text) except json.JSONDecodeError as e: raise DockerManifestError( "Server did not return a valid manifest: {}".format(e), manifest=response.text, ) from e schema_version = manifest.get("schemaVersion") if schema_version == 1: raise DockerManifestError("Schema version 1 is unsupported.", manifest=response.text) if schema_version is None: raise DockerManifestError( "Manifest did not include the schemaVersion key.", manifest=response.text, ) our_digest = self.digest(response.text.encode("utf8")) their_digest = response.headers.get("Docker-Content-Digest") if not their_digest: raise DockerManifestError( "Server did not set the Docker-Content-Digest header.", manifest=response.text, ) if our_digest != their_digest: raise DockerManifestError( "Server returned a non-matching content digest. " "Our digest: {}, their digest: {}".format(our_digest, their_digest), manifest=response.text, ) if manifest["mediaType"] == "application/vnd.docker.distribution.manifest.list.v2+json": # This is a "fat manifest", we need to narrow down to a specific # architecture. for sub in manifest["manifests"]: if sub["platform"]["architecture"] == architecture and sub["platform"]["os"]: sub_digest = sub["digest"] return self.manifest( image_path, sub_digest, architecture=architecture, os_=os_, ) raise DockerManifestError( "No images found for architecture {}, OS {}".format(architecture, os_), manifest=response.text, ) if manifest["mediaType"] == "application/vnd.docker.distribution.manifest.v2+json": return response.text, our_digest else: raise DockerManifestError( "Unsupported manifest type {}".format(manifest["mediaType"]), manifest=response.text, ) # blob(): # # Fetch a blob from the remote registry. This is used for getting each # layer of an image in tar.gz format. # # Raises: # requests.RequestException, if network errors occur # # Args: # image_path (str): Relative path to the image, e.g. library/alpine # blob_digest (str): Content hash of the blob. # download_to (str): Path to a file where the content will be written. def blob(self, image_path, blob_digest, download_to): blob_url = urljoin(image_path, "blobs", urllib.parse.quote(blob_digest)) response = self._request(blob_url, stream=True) with save_file_atomic(download_to, "wb") as f: shutil.copyfileobj(response.raw, f) class ReadableTarInfo(tarfile.TarInfo): """ The goal is to override `TarFile`'s `extractall` semantics by ensuring that on extraction, the files are readable by the owner of the file. This is done by overriding the accessor for the `mode` attribute in `TarInfo`, the class that encapsulates the internal meta-data of the tarball, so that the owner-read bit is always set. """ # https://github.com/python/mypy/issues/4125 @property # type: ignore def mode(self): # Respect umask instead of the file mode stored in the archive. # The only bit used from the embedded mode is the executable bit for files. umask = get_umask() if self.isdir() or bool(self.__permission & 0o100): return 0o777 & ~umask else: return 0o666 & ~umask @mode.setter def mode(self, permission): self.__permission = permission # pylint: disable=attribute-defined-outside-init class DockerSource(Source): # pylint: disable=too-many-instance-attributes BST_MIN_VERSION = "2.5" # Docker identifies images by a content digest calculated from the image's # manifest. This corresponds well with the concept of a 'ref' in # BuildStream. However, Docker theoretically supports multiple hash # methods while BuildStream does not. Right now every Docker registry # uses sha256 so let's ignore that issue for the time being. @staticmethod def _digest_to_ref(digest): if digest.startswith("sha256:"): return digest[len("sha256:") :] else: method = digest.split(":")[0] raise SourceError("Unsupported digest method: {}".format(method)) @staticmethod def _ref_to_digest(ref): return "sha256:" + ref def configure(self, node): # url is deprecated, but accept it as a valid key so that we can raise # a nicer warning. node.validate_keys( Source.COMMON_CONFIG_KEYS + ["architecture", "registry-url", "image", "os", "ref", "track", "url", "version"] ) if "url" in node and ("image" in node or "registry-url" in node): raise SourceError("{}: May specify either 'url', or 'image' and 'registry-url'".format(self)) if "url" not in node and "image" not in node: raise SourceError("{}: Must define either 'url' or 'image'".format(self)) if "url" in node: self.url = node.get_str("url") translated_url = self.translate_url(self.url) scheme, netloc, path, _, _ = urllib.parse.urlsplit(translated_url) self.registry_url = urllib.parse.urlunsplit((scheme, netloc, "", "", "")) self.image = path if "image" in node: self.url = None self.image = node.get_str("image") self.original_registry_url = node.get_str("registry-url", _DOCKER_HUB_URL) self.registry_url = self.translate_url(self.original_registry_url) self.tag = node.get_str("track", "") or None self.architecture = node.get_str("architecture", "") or default_architecture() self.os = node.get_str("os", "") or default_os() self.version = node.get_str("version", None) self.digest = None self.load_ref(node) self.client = DockerRegistryV2Client(self.registry_url) self.manifest = None def load_ref(self, node): ref = node.get_str("ref", None) if ref is not None: self.digest = self._ref_to_digest(ref) def preflight(self): return def get_unique_key(self): if self.url is not None: unique_key = [self.url, self.digest] else: unique_key = [self.original_registry_url, self.image, self.digest] # Backwards compatible method of supporting configuration # attributes which affect SourceInfo generation. if self.version is not None: unique_key.append(self.version) return unique_key def get_ref(self): return None if self.digest is None else self._digest_to_ref(self.digest) def set_ref(self, ref, node): node["ref"] = ref self.digest = self._ref_to_digest(ref) def track(self): # pylint: disable=arguments-differ # If the tracking ref is not specified it's not an error, just silently return if not self.tag: return None with self.timed_activity( "Fetching image manifest for image: '{}:{}' from: {}".format(self.image, self.tag, self.registry_url) ): try: _, digest = self.client.manifest(self.image, self.tag, self.architecture, self.os) except DockerManifestError as e: self.log("Problem downloading manifest", detail=e.manifest) raise except (OSError, requests.RequestException) as e: raise SourceError(e) from e return self._digest_to_ref(digest) def is_resolved(self): return self.digest is not None def is_cached(self): mirror_dir = self.get_mirror_directory() try: manifest = self._load_manifest() for layer in manifest["layers"]: layer_digest = layer["digest"] blob_path = os.path.join(mirror_dir, layer_digest + ".tar.gz") try: self._verify_blob(blob_path, expected_digest=layer_digest) except FileNotFoundError: # digest fetched, but some layer blob not fetched return False return True except (FileNotFoundError, SourceError): return False def _load_manifest(self): manifest_file = os.path.join(self.get_mirror_directory(), self.digest + ".manifest.json") with open(manifest_file, "rb") as f: text = f.read() real_digest = self.client.digest(text) if real_digest != self.digest: raise SourceError("Manifest {} is corrupt; got content hash of {}".format(manifest_file, real_digest)) return json.loads(text.decode("utf-8")) def _save_manifest(self, text, path): manifest_file = os.path.join(path, self.digest + ".manifest.json") with save_file_atomic(manifest_file, "wb") as f: f.write(text.encode("utf-8")) @staticmethod def _verify_blob(path, expected_digest): blob_digest = "sha256:" + sha256sum(path) if expected_digest != blob_digest: raise SourceError("Blob {} is corrupt; got content hash of {}.".format(path, blob_digest)) def fetch(self): # pylint: disable=arguments-differ with self.timed_activity( "Fetching image {}:{} with digest {}".format(self.image, self.tag, self.digest), silent_nested=True, ): with self.tempdir() as tmpdir: # move all files to a tmpdir try: manifest = self._load_manifest() except FileNotFoundError as e: try: manifest_text, digest = self.client.manifest( self.image, self.digest, self.architecture, self.os, ) except requests.RequestException as ee: raise SourceError(ee) from ee if digest != self.digest: raise SourceError( "Requested image {}, got manifest with digest {}".format(self.digest, digest) ) from e self._save_manifest(manifest_text, tmpdir) manifest = json.loads(manifest_text) except DockerManifestError as e: self.log("Unexpected manifest", detail=e.manifest) raise except (OSError, requests.RequestException) as e: raise SourceError(e) from e for layer in manifest["layers"]: if layer["mediaType"] != "application/vnd.docker.image.rootfs.diff.tar.gzip": raise SourceError("Unsupported layer type: {}".format(layer["mediaType"])) layer_digest = layer["digest"] blob_path = os.path.join(tmpdir, layer_digest + ".tar.gz") if not os.path.exists(blob_path): try: self.client.blob(self.image, layer_digest, download_to=blob_path) except (OSError, requests.RequestException) as e: if os.path.exists(blob_path): shutil.rmtree(blob_path) raise SourceError(e) from e self._verify_blob(blob_path, expected_digest=layer_digest) # Only if all sources are successfully fetched, move files to staging directory # As both the manifest and blobs are content addressable, we can optimize space by having # a flat mirror directory. We check one-by-one if there is any need to copy a file out of the tmpdir. for fetched_file in os.listdir(tmpdir): move_atomic( os.path.join(tmpdir, fetched_file), os.path.join(self.get_mirror_directory(), fetched_file), ) def stage(self, directory): mirror_dir = self.get_mirror_directory() try: manifest = self._load_manifest() except (OSError, SourceError) as e: raise SourceError("Unable to load manifest: {}".format(e)) from e try: layer_members = [] # Create a list of members to extract from each layer for layer in manifest["layers"]: layer_digest = layer["digest"] blob_path = os.path.join(mirror_dir, layer_digest + ".tar.gz") self._verify_blob(blob_path, expected_digest=layer_digest) members_dict, whiteout_paths, opaque_whiteout_dirs = self._get_members_and_whiteout_paths(blob_path) # Process opaque whiteouts: remove members under the corresponding directories from previous layers for _, prev_members_dict in layer_members: members_to_remove = [] for member_path in prev_members_dict: # Check if this member should be removed by any opaque whiteout for opaque_whiteout_dir in opaque_whiteout_dirs: if member_path.startswith(opaque_whiteout_dir): members_to_remove.append(member_path) break for member_path in members_to_remove: del prev_members_dict[member_path] # Process whiteouts: remove corresponding members from previous layers for _, prev_members_dict in layer_members: for whiteout_path in whiteout_paths: prev_members_dict.pop(whiteout_path, None) layer_members.append((blob_path, members_dict)) # Extract files for each layer for blob_path, members_dict in layer_members: if not members_dict: # No files to extract from this layer continue # Extract files for the current layer with tarfile.open(blob_path, tarinfo=ReadableTarInfo) as tar: with self.tempdir() as td: members = list(members_dict.values()) if hasattr(tarfile, "tar_filter"): # Python 3.12+ (and older versions with backports) tar.extraction_filter = tarfile.tar_filter else: for member in members: self._assert_tarinfo_safe(member, td) tar.extractall(path=td, members=members) link_files(td, directory) except (OSError, SourceError, tarfile.TarError) as e: raise SourceError("{}: Error staging source: {}".format(self, e)) from e def collect_source_info(self): # If the image was configured with "url" only rather # than "registry-url" and "image", then self.image # at this point will have a leading forward slash "/". # # Lets just normalize that problem here, as changing # the self.image itself can break cache keys. # image_name = self.image.lstrip("/") return [ self.create_source_info( self.registry_url, SourceInfoMedium.OCI_IMAGE, SourceVersionType.OCI_DIGEST, self.digest, version_guess=self.version, extra_data={"image-name": image_name}, ) ] @staticmethod def _get_members_and_whiteout_paths(layer_tar_path): """Return the set of files to remove and extract for a given layer :param layer_tar_path: The path to the layer tar.gz file :return: Tuple of (members_dict, whiteout_paths, opaque_whiteout_dirs) - members_dict: OrderedDict of TarInfo members to extract into staging directory - whiteout_paths: list of file paths that should be removed from previous layers - opaque_whiteout_dirs: list of directory paths whose contents should be removed from previous layers """ def strip_wh(white_out_file): """Strip the prefixing .wh. for given file :param white_out_file: path of file :return: path without white-out prefix """ # whiteout files have the syntax of `*/.wh.*` file_name = os.path.basename(white_out_file) path = os.path.join(os.path.dirname(white_out_file), file_name.split(".wh.", maxsplit=1)[1]) return path def is_regular_file(info): """Check if file is a non-device file :param info: tar member metadata :return: if the file is a non-device file """ return not (info.name.startswith("dev/") or info.isdev()) with tarfile.open(layer_tar_path, tarinfo=ReadableTarInfo) as tar: members_dict = OrderedDict() whiteout_paths = [] opaque_whiteout_dirs = [] for member in tar.getmembers(): member_basename = os.path.basename(member.name) if member_basename == ".wh..wh..opq": # Opaque whiteout file opaque_whiteout_dir = os.path.dirname(member.name) if opaque_whiteout_dir != "": # Add "/" to facilitate path prefix matching opaque_whiteout_dir += "/" opaque_whiteout_dirs.append(opaque_whiteout_dir) elif member_basename.startswith(".wh."): # Whiteout file whiteout_paths.append(strip_wh(member.name)) elif is_regular_file(member): members_dict[member.name] = member return members_dict, whiteout_paths, opaque_whiteout_dirs # Assert that a tarfile is safe to extract; specifically, make # sure that we don't do anything outside of the target # directory (this is possible, if, say, someone engineered a # tarfile to contain paths that start with ..). def _assert_tarinfo_safe(self, member: tarfile.TarInfo, target_dir: str): final_path = os.path.abspath(os.path.join(target_dir, member.path)) if not final_path.startswith(target_dir): raise SourceError( "{}: Tarfile attempts to extract outside the staging area: " "{} -> {}".format(self, member.path, final_path) ) if member.islnk(): linked_path = os.path.abspath(os.path.join(target_dir, member.linkname)) if not linked_path.startswith(target_dir): raise SourceError( "{}: Tarfile attempts to hardlink outside the staging area: " "{} -> {}".format(self, member.path, final_path) ) # Don't need to worry about symlinks because they're just # files here and won't be able to do much harm once we are # in a sandbox. # Plugin entry point def setup(): return DockerSource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/git.py0000644000175100017510000012735515152545021024350 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Tristan Van Berkom # Chandan Singh # Tom Mewett # # This plugin was originally developped in the https://github.com/apache/buildstream/ # repository and was copied from 1a3c707a6c46573ab159de64ac9cd92e7f6027e6 # """ git - stage files from a git repository ======================================= **Host dependencies:** * git .. attention:: Note that this plugin **will checkout git submodules by default**; even if they are not specified in the `.bst` file. **Usage:** .. code:: yaml # Specify the git source kind kind: git # Specify the repository url, using an alias defined # in your project configuration is recommended. url: upstream:foo.git # Optionally specify a symbolic tracking branch or tag, this # will be used to update the 'ref' when refreshing the pipeline. track: master # Optionally specify the ref format used for tracking. # The default is 'sha1' for the raw commit hash. # If you specify 'git-describe', the commit hash will be prefixed # with the closest tag. ref-format: sha1 # Specify the commit ref, this must be specified in order to # checkout sources and build, but can be automatically updated # if the 'track' attribute was specified. ref: d63cbb6fdc0bbdadc4a1b92284826a6d63a7ebcd # Optionally specify whether submodules should be checked-out. # This is done recursively, as with `git clone --recurse-submodules`. # If not set, this will default to 'True' checkout-submodules: True # If your repository has submodules, explicitly specifying the # url from which they are to be fetched allows you to easily # rebuild the same sources from a different location. This is # especially handy when used with project defined aliases which # can be redefined at a later time, or overridden with mirrors. # # You may also explicitly specify whether to check out this # submodule. If 'checkout' is set, it will control whether to # checkout that submodule and recurse into it. It defaults to the # value of 'checkout-submodules'. submodules: plugins/bar: url: upstream:bar.git checkout: True plugins/bar/quux: checkout: False plugins/baz: url: upstream:baz.git checkout: False # Modify the default version guessing pattern # # Since 2.5 # version-guess-pattern: \'(\\d+)\\.(\\d+)(?:\\.(\\d+))?\' # Override the version guessing with an explicit version # # Since 2.5 # version: 5.9 # Enable tag tracking. # # This causes the `tags` metadata to be populated automatically # as a result of tracking the git source. # # By default this is 'False'. # track-tags: True # If the list of tags below is set, then a lightweight dummy # git repository will be staged along with the content at # build time. # # This is useful for a growing number of modules which use # `git describe` at build time in order to determine the version # which will be encoded into the built software. # # The 'tags' below is considered as a part of the git source # reference and will be stored in the 'project.refs' file if # that has been selected as your project's ref-storage. # # Migration notes: # # If you are upgrading from BuildStream 1.2, which used to # stage the entire repository by default, you will notice that # some modules which use `git describe` are broken, and will # need to enable this feature in order to fix them. # # If you need to enable this feature without changing the # the specific commit that you are building, then we recommend # the following migration steps for any git sources where # `git describe` is required: # # o Enable `track-tags` feature # o Set the `track` parameter to the desired commit sha which # the current `ref` points to # o Run `bst source track` for these elements, this will result in # populating the `tags` portion of the refs without changing # the refs # o Restore the `track` parameter to the branches which you have # previously been tracking afterwards. # tags: - tag: lightweight-example commit: 04ad0dc656cb7cc6feb781aa13bdbf1d67d0af78 annotated: false - tag: annotated-example commit: 10abe77fe8d77385d86f225b503d9185f4ef7f3a annotated: true See `built-in functionality doumentation `_ for details on common configuration options for sources. Configurable Warnings: ~~~~~~~~~~~~~~~~~~~~~~ This plugin provides the following `configurable warnings `_: - ``git:inconsistent-submodule`` - A submodule present in the git repository's .gitmodules was never added with `git submodule add`. - ``git:unlisted-submodule`` - A submodule is present in the git repository but was not specified in the source configuration and was not disabled for checkout. - ``git:invalid-submodule`` - A submodule is specified in the source configuration but does not exist in the repository. This plugin also utilises the following configurable `core warnings `_: - `ref-not-in-track `_ - The provided ref was not found in the provided track in the element's git repository. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The git source reports the URL of the git repository as the *url*. Further, the git source reports the `SourceInfoMedium.GIT `_ *medium* and the `SourceVersionType.COMMIT `_ *version_type*, for which it reports the git commit sha as the *version*. If the ref is found to be in ``git-describe`` format, an attempt to guess the version based on the git tag portion of the ref will be made for the reporting of the *guess_version*. Control over how the guess is made or overridden is controlled based on the ``version-guess-pattern`` and ``version`` configuration attributes described above. In order to understand how the ``version-guess-pattern`` works, please refer to the documentation for `utils.guess_version() `_ In the case that a git describe string represents a commit that is beyond the tag portion of the git describe reference (i.e. the version is not exact), then the number of commits found beyond the tag will be reported in the ``commit-offset`` field of the *extra_data*. .. attention:: SourceInfo is **not** reported for submodules. This is due to the limitation that the git plugin requires to have the toplevel module fetched first in order to have knowledge of the commits of the submodules. While this does not provide *complete* information on the provenance of sources, at least one can consider the module to be a comprehensive whole, and the versions of submodules are deterministically controlled by the version of the main repository. """ import os import re import shutil from io import StringIO from tempfile import TemporaryFile from configparser import RawConfigParser from buildstream import Source, SourceError, SourceFetcher from buildstream import CoreWarnings, FastEnum from buildstream import utils from buildstream.utils import DirectoryExistsError # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass GIT_MODULES = ".gitmodules" EXACT_TAG_PATTERN = r"(?P.*)-0-g(?P.*)" # Warnings WARN_INCONSISTENT_SUBMODULE = "inconsistent-submodule" WARN_UNLISTED_SUBMODULE = "unlisted-submodule" WARN_INVALID_SUBMODULE = "invalid-submodule" class _RefFormat(FastEnum): SHA1 = "sha1" GIT_DESCRIBE = "git-describe" def _strip_tag(rev): return rev.split("-g")[-1] # This class represents a single Git repository. The Git source needs to account for # submodules, but we don't want to cache them all under the umbrella of the # superproject - so we use this class which caches them independently, according # to their URL. Instances keep reference to their "parent" GitSource, # and if applicable, where in the superproject they are found. # # Args: # source (GitSource): The parent source # path (str): The relative location of the submodule in the superproject; # the empty string for the superproject itself # url (str): Where to clone the repo from # ref (str): Specified 'ref' from the source configuration # primary (bool): Whether this is the primary URL for the source # tags (list): Tag configuration; see GitSource._load_tags # class GitMirror(SourceFetcher): def __init__(self, source, path, url, ref, *, primary=False, tags=None): super().__init__() self.source = source self.path = path self.url = url self.ref = ref self.tags = tags or [] self.primary = primary self.mirror = os.path.join(source.get_mirror_directory(), utils.url_directory_name(url)) # _ensure_repo(): # # Ensures that the Git repository exists at the mirror location and is configured # to fetch from the given URL # def _ensure_repo(self): if not os.path.exists(self.mirror): with self.source.tempdir() as tmpdir: self.source.call( [self.source.host_git, "init", "--bare", tmpdir], fail="Failed to initialise repository", ) try: utils.move_atomic(tmpdir, self.mirror) except DirectoryExistsError: # Another process was quicker to download this repository. # Let's discard our own self.source.status("{}: Discarding duplicate repository".format(self.source)) except OSError as e: raise SourceError( "{}: Failed to move created repository from '{}' to '{}': {}".format( self.source, tmpdir, self.mirror, e ) ) from e def _fetch(self, url, fetch_all=False): self._ensure_repo() # Work out whether we can fetch a specific tag: are we given a ref which # 1. is in git-describe format # 2. refers to an exact tag (is "...-0-g...") # 3. is available on the remote and tags the specified commit? # And lastly: are we on a new-enough Git which allows cloning from our potentially shallow cache? if fetch_all: pass # Fetching from a shallow-cloned repo was first supported in v1.9.0 elif not self.ref or self.source.host_git_version is not None and self.source.host_git_version < (1, 9, 0): fetch_all = True else: m = re.match(EXACT_TAG_PATTERN, self.ref) if m is None: fetch_all = True else: tag = m.group("tag") commit = m.group("commit") if not self.remote_has_tag(url, tag, commit): self.source.status( "{}: {} is not advertised on {}. Fetching all Git refs".format(self.source, self.ref, url) ) fetch_all = True else: exit_code = self.source.call( [ self.source.host_git, "fetch", "--depth=1", url, "+refs/tags/{tag}:refs/tags/{tag}".format(tag=tag), ], cwd=self.mirror, ) if exit_code != 0: self.source.status( "{}: Failed to fetch tag '{}' from {}. Fetching all Git refs".format(self.source, tag, url) ) fetch_all = True if fetch_all: self.source.call( [ self.source.host_git, "fetch", "--prune", url, "+refs/heads/*:refs/heads/*", "+refs/tags/*:refs/tags/*", ], fail="Failed to fetch from remote git repository: {}".format(url), fail_temporarily=True, cwd=self.mirror, ) def fetch(self, alias_override=None): # pylint: disable=arguments-differ resolved_url = self.source.translate_url(self.url, alias_override=alias_override, primary=self.primary) with self.source.timed_activity("Fetching from {}".format(resolved_url), silent_nested=True): if not self.has_ref(): self._fetch(resolved_url) self.assert_ref() def has_ref(self): if not self.ref: return False # If the mirror doesnt exist, we also dont have the ref if not os.path.exists(self.mirror): return False # Check if the ref is really there rc = self.source.call([self.source.host_git, "cat-file", "-t", self.ref], cwd=self.mirror) return rc == 0 def assert_ref(self): if not self.has_ref(): raise SourceError( "{}: expected ref '{}' was not found in git repository: '{}'".format(self.source, self.ref, self.url) ) # remote_has_tag(): # # Args: # url (str) # tag (str) # commit (str) # # Returns: # (bool): Whether the remote at `url` has the tag `tag` attached to `commit` # def remote_has_tag(self, url, tag, commit): _, ls_remote = self.source.check_output( [self.source.host_git, "ls-remote", url], cwd=self.mirror, fail="Failed to list advertised remote refs from git repository {}".format(url), ) line = "{commit}\trefs/tags/{tag}".format(commit=commit, tag=tag) return line in ls_remote or line + "^{}" in ls_remote # to_commit(): # # Args: # rev (str): A Git "commit-ish" rev # # Returns: # (str): The full revision ID of the commit # def to_commit(self, rev): _, output = self.source.check_output( [self.source.host_git, "rev-list", "-n", "1", rev], fail="Unable to find revision {}".format(rev), cwd=self.mirror, ) return output.strip() # describe(): # # Args: # rev (str): A Git "commit-ish" rev # # Returns: # (str): The full revision ID of the commit given by rev, prepended # with tag information as given by git-describe (where available) # def describe(self, rev): _, output = self.source.check_output( [ self.source.host_git, "describe", "--tags", "--abbrev=40", "--long", "--always", rev, ], fail="Unable to find revision {}".format(rev), cwd=self.mirror, ) return output.strip() # reachable_tags(): # # Args: # rev (str): A Git "commit-ish" rev # # Returns: # (list): A list of tags in the ancestry of rev. Each entry is a triple of the form # (tag name (str), commit ref (str), annotated (bool)) describing a tag, # its tagged commit and whether it's annotated # def reachable_tags(self, rev): tags = set() for options in [ [], ["--first-parent"], ["--tags"], ["--tags", "--first-parent"], ]: exit_code, output = self.source.check_output( [ self.source.host_git, "describe", "--abbrev=0", rev, *options, ], cwd=self.mirror, ) if exit_code == 0: tag = output.strip() _, commit_ref = self.source.check_output( [self.source.host_git, "rev-parse", tag + "^{commit}"], fail="Unable to resolve tag '{}'".format(tag), cwd=self.mirror, ) exit_code = self.source.call( [self.source.host_git, "cat-file", "tag", tag], cwd=self.mirror, ) annotated = exit_code == 0 tags.add((tag, commit_ref.strip(), annotated)) return list(tags) def stage(self, directory): fullpath = os.path.join(directory, self.path) # Using --shared here avoids copying the objects into the checkout, in any # case we're just checking out a specific commit and then removing the .git/ # directory. self.source.call( [ self.source.host_git, "clone", "--no-checkout", "--shared", self.mirror, fullpath, ], fail="Failed to create git mirror {} in directory: {}".format(self.mirror, fullpath), fail_temporarily=True, ) self.source.call( [self.source.host_git, "checkout", "--force", self.ref], fail="Failed to checkout git ref {}".format(self.ref), cwd=fullpath, ) # Remove .git dir shutil.rmtree(os.path.join(fullpath, ".git")) self._rebuild_git(fullpath) def init_workspace(self, directory): fullpath = os.path.join(directory, self.path) url = self.source.translate_url(self.url) self.source.call( [ self.source.host_git, "clone", "--no-checkout", self.mirror, fullpath, ], fail="Failed to clone git mirror {} in directory: {}".format(self.mirror, fullpath), fail_temporarily=True, ) self.source.call( [self.source.host_git, "remote", "set-url", "origin", url], fail='Failed to add remote origin "{}"'.format(url), cwd=fullpath, ) self.source.call( [self.source.host_git, "checkout", "--force", self.ref], fail="Failed to checkout git ref {}".format(self.ref), cwd=fullpath, ) # get_submodule_mirrors(): # # Returns: # An iterator through new instances of this class, one of each submodule # in the repo # def get_submodule_mirrors(self): for path, url in self.submodule_list(): ref = self.submodule_ref(path) if ref is not None: mirror = self.__class__(self.source, os.path.join(self.path, path), url, ref) yield mirror # List the submodules (path/url tuples) present at the given ref of this repo def submodule_list(self): modules = "{}:{}".format(self.ref, GIT_MODULES) exit_code, output = self.source.check_output([self.source.host_git, "show", modules], cwd=self.mirror) # If git show reports error code 128 here, we take it to mean there is # no .gitmodules file to display for the given revision. if exit_code == 128: return elif exit_code != 0: raise SourceError("{plugin}: Failed to show gitmodules at ref {ref}".format(plugin=self, ref=self.ref)) content = "\n".join([l.strip() for l in output.splitlines()]) io = StringIO(content) parser = RawConfigParser() parser.read_file(io) 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 (path, url) # Fetch the ref which this mirror requires its submodule to have, # at the given ref of this mirror. def submodule_ref(self, submodule, ref=None): if not ref: ref = self.ref # list objects in the parent repo tree to find the commit # object that corresponds to the submodule _, output = self.source.check_output( [self.source.host_git, "ls-tree", ref, submodule], fail="ls-tree failed for commit {} and submodule: {}".format(ref, submodule), cwd=self.mirror, ) # read the commit hash from the output fields = output.split() if len(fields) >= 2 and fields[1] == "commit": submodule_commit = output.split()[2] # fail if the commit hash is invalid if len(submodule_commit) != 40: raise SourceError( "{}: Error reading commit information for submodule '{}'".format(self.source, submodule) ) return submodule_commit else: detail = ( "The submodule '{}' is defined either in the BuildStream source\n".format(submodule) + "definition, or in a .gitmodules file. But the submodule was never added to the\n" + "underlying git repository with `git submodule add`." ) self.source.warn( "{}: Ignoring inconsistent submodule '{}'".format(self.source, submodule), detail=detail, warning_token=WARN_INCONSISTENT_SUBMODULE, ) return None def _rebuild_git(self, fullpath): if not self.tags: return with self.source.tempdir() as tmpdir: included = set() shallow = set() for _, commit_ref, _ in self.tags: if commit_ref == self.ref: # rev-list does not work in case of same rev shallow.add(self.ref) else: _, out = self.source.check_output( [ self.source.host_git, "rev-list", "--ancestry-path", "--boundary", "{}..{}".format(commit_ref, self.ref), ], fail="Failed to get git history {}..{} in directory: {}".format( commit_ref, self.ref, fullpath ), fail_temporarily=True, cwd=self.mirror, ) self.source.warn("refs {}..{}: {}".format(commit_ref, self.ref, out.splitlines())) for line in out.splitlines(): rev = line.lstrip("-") if line[0] == "-": shallow.add(rev) else: included.add(rev) shallow -= included included |= shallow self.source.call( [self.source.host_git, "init"], fail="Cannot initialize git repository: {}".format(fullpath), cwd=fullpath, ) for rev in included: with TemporaryFile(dir=tmpdir) as commit_file: self.source.call( [self.source.host_git, "cat-file", "commit", rev], stdout=commit_file, fail="Failed to get commit {}".format(rev), cwd=self.mirror, ) commit_file.seek(0, 0) self.source.call( [ self.source.host_git, "hash-object", "-w", "-t", "commit", "--stdin", ], stdin=commit_file, fail="Failed to add commit object {}".format(rev), cwd=fullpath, ) with open( os.path.join(fullpath, ".git", "shallow"), "w", encoding="utf-8", ) as shallow_file: for rev in shallow: shallow_file.write("{}\n".format(rev)) for tag, commit_ref, annotated in self.tags: if annotated: with TemporaryFile(dir=tmpdir) as tag_file: tag_data = "object {}\ntype commit\ntag {}\ntagger Unspecified Tagger 0 +0000\n".format( commit_ref, tag ) tag_file.write(tag_data.encode("ascii")) tag_file.seek(0, 0) _, tag_ref = self.source.check_output( [ self.source.host_git, "hash-object", "-w", "-t", "tag", "--stdin", ], stdin=tag_file, fail="Failed to add tag object {}".format(tag), cwd=fullpath, ) self.source.call( [self.source.host_git, "tag", tag, tag_ref.strip()], fail="Failed to tag: {}".format(tag), cwd=fullpath, ) else: self.source.call( [self.source.host_git, "tag", tag, commit_ref], fail="Failed to tag: {}".format(tag), cwd=fullpath, ) with open(os.path.join(fullpath, ".git", "HEAD"), "w", encoding="utf-8") as head: self.source.call( [self.source.host_git, "rev-parse", self.ref], stdout=head, fail="Failed to parse commit {}".format(self.ref), cwd=self.mirror, ) class GitSource(Source): # pylint: disable=attribute-defined-outside-init BST_MIN_VERSION = "2.5" def configure(self, node): ref = node.get_str("ref", None) config_keys = [ "url", "track", "ref", "submodules", "checkout-submodules", "ref-format", "track-tags", "tags", "version", "version-guess-pattern", ] node.validate_keys(config_keys + Source.COMMON_CONFIG_KEYS) tags_node = node.get_sequence("tags", []) for tag_node in tags_node: tag_node.validate_keys(["tag", "commit", "annotated"]) tags = self._load_tags(node) self.track_tags = node.get_bool("track-tags", default=False) self.original_url = node.get_str("url") self.mirror = GitMirror(self, "", self.original_url, ref, tags=tags, primary=True) self.tracking = node.get_str("track", None) self.ref_format = node.get_enum("ref-format", _RefFormat, _RefFormat.SHA1) self.guess_pattern_string = node.get_str("version-guess-pattern", None) self.guess_pattern = None if self.guess_pattern_string is not None: self.guess_pattern = re.compile(self.guess_pattern_string) # Get the explicitly set guess_version for the toplevel git repo self.version = node.get_str("version", None) # At this point we now know if the source has a ref and/or a track. # If it is missing both then we will be unable to track or build. if self.mirror.ref is None and self.tracking is None: raise SourceError( "{}: Git sources require a ref and/or track".format(self), reason="missing-track-and-ref", ) self.checkout_submodules = node.get_bool("checkout-submodules", default=True) # Parse a dict of submodule overrides, stored in the submodule_overrides # and submodule_checkout_overrides dictionaries. self.submodule_overrides = {} self.submodule_checkout_overrides = {} modules = node.get_mapping("submodules", {}) for path in modules.keys(): submodule = modules.get_mapping(path) url = submodule.get_str("url", None) # Make sure to mark all URLs that are specified in the configuration if url: self.mark_download_url(url, primary=False) self.submodule_overrides[path] = url if "checkout" in submodule: checkout = submodule.get_bool("checkout") self.submodule_checkout_overrides[path] = checkout self.mark_download_url(self.original_url) def preflight(self): # Check if git is installed, get the binary at the same time self.host_git = utils.get_host_tool("git") rc, version_str = self.check_output([self.host_git, "--version"]) # e.g. on Git for Windows we get "git version 2.21.0.windows.1". # e.g. on Mac via Homebrew we get "git version 2.19.0". if rc == 0: self.host_git_version = tuple(int(x) for x in version_str.split(" ")[2].split(".")[:3]) else: self.host_git_version = None def get_unique_key(self): ref = self.mirror.ref if ref is not None: # Strip any (arbitary) tag information, leaving just the commit ID ref = _strip_tag(ref) # Here we want to encode the local name of the repository and # the ref, if the user changes the alias to fetch the same sources # from another location, it should not affect the cache key. key = [self.original_url, ref] if self.mirror.tags: tags = {tag: (commit, annotated) for tag, commit, annotated in self.mirror.tags} key.append({"tags": tags}) # Only modify the cache key with checkout_submodules if it's something # other than the default behaviour. if self.checkout_submodules is False: key.append({"checkout_submodules": self.checkout_submodules}) # We want the cache key to change if the source was # configured differently, and submodules count. if self.submodule_overrides: key.append(self.submodule_overrides) if self.submodule_checkout_overrides: key.append({"submodule_checkout_overrides": self.submodule_checkout_overrides}) # Backwards compatible method of supporting configuration # attributes which affect SourceInfo generation. if self.version is not None: key.append(self.version) elif self.guess_pattern_string is not None: key.append(self.guess_pattern_string) return key def is_resolved(self): return self.mirror.ref is not None def is_cached(self): return self._have_all_refs() def load_ref(self, node): self.mirror.ref = node.get_str("ref", None) self.mirror.tags = self._load_tags(node) def get_ref(self): if self.mirror.ref is None: return None return self.mirror.ref, self.mirror.tags def set_ref(self, ref, node): if not ref: self.mirror.ref = None if "ref" in node: del node["ref"] self.mirror.tags = [] if "tags" in node: del node["tags"] else: actual_ref, tags = ref node["ref"] = self.mirror.ref = actual_ref self.mirror.tags = tags if tags: node["tags"] = [ { "tag": tag, "commit": commit_ref, "annotated": annotated, } for tag, commit_ref, annotated in tags ] else: if "tags" in node: del node["tags"] def track(self): # pylint: disable=arguments-differ # If self.tracking is not specified it's not an error, just silently return if not self.tracking: # Is there a better way to check if a ref is given. if self.mirror.ref is None: detail = "Without a tracking branch ref can not be updated. Please " + "provide a ref or a track." raise SourceError( "{}: No track or ref".format(self), detail=detail, reason="track-attempt-no-track", ) return None # Resolve the URL for the message resolved_url = self.translate_url(self.mirror.url) with self.timed_activity( "Tracking {} from {}".format(self.tracking, resolved_url), silent_nested=True, ): self.mirror._fetch(resolved_url, fetch_all=True) ref = self.mirror.to_commit(self.tracking) tags = self.mirror.reachable_tags(ref) if self.track_tags else [] if self.ref_format == _RefFormat.GIT_DESCRIBE: ref = self.mirror.describe(ref) return ref, tags def init_workspace(self, directory): with self.timed_activity('Setting up workspace "{}"'.format(directory), silent_nested=True): self.mirror.init_workspace(directory) for mirror in self._recurse_submodules(configure=True): mirror.init_workspace(directory) def stage(self, directory): # Stage the main repo in the specified directory # with self.timed_activity("Staging {}".format(self.mirror.url), silent_nested=True): self.mirror.stage(directory) for mirror in self._recurse_submodules(configure=True): mirror.stage(directory) def get_source_fetchers(self): self.mirror.mark_download_url(self.mirror.url) yield self.mirror # _recurse_submodules only iterates those which are known at the current # cached state - but fetch is called on each result as we go, so this will # yield all configured submodules for submodule in self._recurse_submodules(configure=True): submodule.mark_download_url(submodule.url) yield submodule def validate_cache(self): discovered_submodules = {} unlisted_submodules = [] invalid_submodules = [] for submodule in self._recurse_submodules(configure=False): discovered_submodules[submodule.path] = submodule.url if self._ignoring_submodule(submodule.path): continue if submodule.path not in self.submodule_overrides: unlisted_submodules.append((submodule.path, submodule.url)) # Warn about submodules which are explicitly configured but do not exist for path, url in self.submodule_overrides.items(): if path not in discovered_submodules: invalid_submodules.append((path, url)) if invalid_submodules: detail = [] for path, url in invalid_submodules: detail.append(" Submodule URL '{}' at path '{}'".format(url, path)) self.warn( "{}: Invalid submodules specified".format(self), warning_token=WARN_INVALID_SUBMODULE, detail="The following submodules are specified in the source " "description but do not exist according to the repository\n\n" + "\n".join(detail), ) # Warn about submodules which exist but have not been explicitly configured if unlisted_submodules: detail = [] for path, url in unlisted_submodules: detail.append(" Submodule URL '{}' at path '{}'".format(url, path)) self.warn( "{}: Unlisted submodules exist".format(self), warning_token=WARN_UNLISTED_SUBMODULE, detail="The following submodules exist but are not specified " + "in the source description\n\n" + "\n".join(detail), ) # Assert that the ref exists in the track tag/branch, if track has been specified. # Also don't do this check if an exact tag ref is given, as we probably didn't fetch # any branch refs ref_in_track = False if not re.match(EXACT_TAG_PATTERN, self.mirror.ref) and self.tracking: _, branch = self.check_output( [ self.host_git, "branch", "--list", self.tracking, "--contains", self.mirror.ref, ], cwd=self.mirror.mirror, ) if branch: ref_in_track = True else: _, tag = self.check_output( [ self.host_git, "tag", "--list", self.tracking, "--contains", self.mirror.ref, ], cwd=self.mirror.mirror, ) if tag: ref_in_track = True if not ref_in_track: detail = ( "The ref provided for the element does not exist locally " + "in the provided track branch / tag '{}'.\n".format(self.tracking) + "You may wish to track the element to update the ref from '{}' ".format(self.tracking) + "with `bst source track`,\n" + "or examine the upstream at '{}' for the specific ref.".format(self.mirror.url) ) self.warn( "{}: expected ref '{}' was not found in given track '{}' for staged repository: '{}'\n".format( self, self.mirror.ref, self.tracking, self.mirror.url ), detail=detail, warning_token=CoreWarnings.REF_NOT_IN_TRACK, ) # _guess_version() # # Guess the version, in the case the ref is recorded in git-describe format # # Returns: a three-tuple composed of the following three values: # - the version (a git sha) # - the version_guess (as guessed from the tag portion of a git describe string) # - the number of commits beyond the tag (indicating that the guessed version is in this case inexact) # # All returns are either None or strings, only the "sha" is guaranteed to be discovered. # def _guess_version(self): version_guess = self.version commits = None commit_sha = None string = self.mirror.ref main_split = string.rsplit("-g", 1) if len(main_split) < 2: # Didn't find the `-g`, assume its a raw git sha as input commit_sha = string else: # Split out the commits and the tag portion (which may also contain '-') commit_sha = main_split[1] sub_split = main_split[0].rsplit("-", 1) commits = sub_split[1] if commits == "0": commits = None # Run the guess logic on the tag portion of the git describe string if version_guess is None: version_guess = utils.guess_version(sub_split[0], pattern=self.guess_pattern) return (commit_sha, version_guess, commits) def collect_source_info(self): extra_data = None commit_sha, version_guess, commits = self._guess_version() if commits: extra_data = {"commit-offset": commits} return [ self.create_source_info( self.mirror.url, SourceInfoMedium.GIT, SourceVersionType.COMMIT, commit_sha, version_guess=version_guess, extra_data=extra_data, ) ] ########################################################### # Local Functions # ########################################################### def _have_all_refs(self): return self.mirror.has_ref() and all( submodule.has_ref() for submodule in self._recurse_submodules(configure=True) ) # _configure_submodules(): # # Args: # submodules: An iterator of GitMirror (or similar) objects for submodules # # Returns: # An iterator through `submodules` but filtered of any ignored submodules # and modified to use any custom URLs configured in the source # def _configure_submodules(self, submodules): for submodule in submodules: if self._ignoring_submodule(submodule.path): continue # Allow configuration to override the upstream location of the submodules. submodule.url = self.submodule_overrides.get(submodule.path, submodule.url) yield submodule # _recurse_submodules(): # # Recursively iterates through GitMirrors for submodules of the main repo. Only # submodules that are cached are recursed into - but this is decided at # iteration time, so you can fetch in a for loop over this function to fetch # all submodules. # # Args: # configure (bool): Whether to apply the 'submodule' config while recursing # (URL changing and 'checkout' overrides) # def _recurse_submodules(self, configure): def recurse(mirror): submodules = mirror.get_submodule_mirrors() if configure: submodules = self._configure_submodules(submodules) for submodule in submodules: yield submodule if submodule.has_ref(): yield from recurse(submodule) yield from recurse(self.mirror) def _load_tags(self, node): tags = [] tags_node = node.get_sequence("tags", []) for tag_node in tags_node: tag = tag_node.get_str("tag") commit_ref = tag_node.get_str("commit") annotated = tag_node.get_bool("annotated") tags.append((tag, commit_ref, annotated)) return tags # _ignoring_submodule(): # # Args: # path (str): The path of a submodule in the superproject # # Returns: # (bool): Whether to not clone/checkout this submodule # def _ignoring_submodule(self, path): return not self.submodule_checkout_overrides.get(path, self.checkout_submodules) # Plugin entry point def setup(): return GitSource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/patch.py0000644000175100017510000001133215152545021024647 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Chandan Singh # Tiago Gomes # # This plugin was originally developped in the https://github.com/apache/buildstream/ # repository and was copied from 1a3c707a6c46573ab159de64ac9cd92e7f6027e6 # """ patch - apply locally stored patches ==================================== **Host dependencies:** * patch **Usage:** .. code:: yaml # Specify the local source kind kind: patch # Specify the project relative path to a patch file path: files/somefile.diff # Optionally specify the strip level, defaults to 1 strip-level: 1 See `built-in functionality doumentation `_ for details on common configuration options for sources. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The patch source reports the project relative path of the patch file as the *url*. Further, the patch source reports the `SourceInfoMedium.LOCAL `_ *medium* and the `SourceVersionType.SHA256 `_ *version_type*, for which it reports the sha256 checksum of the patch file as the *version*. The *guess_version* of a patch source is meaningless, as it is tied instead to the BuildStream project in which it is contained. """ import os from buildstream import Source, SourceError from buildstream import utils # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass class PatchSource(Source): # pylint: disable=attribute-defined-outside-init BST_MIN_VERSION = "2.5" BST_REQUIRES_PREVIOUS_SOURCES_STAGE = True def configure(self, node): node.validate_keys(["path", "strip-level", *Source.COMMON_CONFIG_KEYS]) self.path = self.node_get_project_path(node.get_scalar("path"), check_is_file=True) self.strip_level = node.get_int("strip-level", default=1) self.fullpath = os.path.join(self.get_project_directory(), self.path) self.sha256 = None def preflight(self): # Check if patch is installed, get the binary at the same time self.host_patch = utils.get_host_tool("patch") def get_unique_key(self): self.sha256 = utils.sha256sum(self.fullpath) return [self.path, self.sha256, self.strip_level] def is_resolved(self): return True def is_cached(self): return True def load_ref(self, node): pass def get_ref(self): return None # pragma: nocover def set_ref(self, ref, node): pass # pragma: nocover def fetch(self): # pylint: disable=arguments-differ # Nothing to do here for a local source pass # pragma: nocover def stage(self, directory): with self.timed_activity("Applying local patch: {}".format(self.path)): # Bail out with a comprehensive message if the target directory is empty if not os.listdir(directory): raise SourceError( "Nothing to patch in directory '{}'".format(directory), reason="patch-no-files", ) strip_level_option = "-p{}".format(self.strip_level) self.call( [ self.host_patch, strip_level_option, "-i", self.fullpath, "-d", directory, ], fail="Failed to apply patch {}".format(self.path), ) def collect_source_info(self): return [self.create_source_info(self.path, SourceInfoMedium.LOCAL, SourceVersionType.SHA256, self.sha256)] # Plugin entry point def setup(): return PatchSource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800529.0 buildstream_plugins-2.7.0/src/buildstream_plugins/sources/pip.py0000644000175100017510000002576215152545021024354 0ustar00juergjuerg# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Authors: # Chandan Singh # # This plugin was originally developped in the https://github.com/apache/buildstream/ # repository and was copied from 1a3c707a6c46573ab159de64ac9cd92e7f6027e6 # """ pip - stage python packages using pip ===================================== **Host depndencies:** * ``pip`` python module This plugin will download source distributions for specified packages using ``pip`` but will not install them. It is expected that the elements using this source will install the downloaded packages. Downloaded tarballs will be stored in a directory called ".bst_pip_downloads". **Usage:** .. code:: yaml # Specify the pip source kind kind: pip # Optionally specify index url, defaults to PyPi # This url is used to discover new versions of packages and download them # Projects intending to mirror their sources to a permanent location should # use an aliased url, and declare the alias in the project configuration url: https://mypypi.example.com/simple # Optionally specify the path to requirements files # Note that either 'requirements-files' or 'packages' must be defined requirements-files: - requirements.txt # Optionally specify a list of additional packages # Note that either 'requirements-files' or 'packages' must be defined packages: - flake8 # Specify the ref. It is a list of strings of format # "==", separated by "\\n". # Usually this will be contents of a requirements.txt file where all # package versions have been frozen. ref: "flake8==3.5.0\\nmccabe==0.6.1\\npkg-resources==0.0.0\\npycodestyle==2.3.1\\npyflakes==1.6.0" See `built-in functionality doumentation `_ for details on common configuration options for sources. Reporting `SourceInfo `_ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The pip source reports the python package index (PyPI) instance as the *url*. Further, the pip source reports the `SourceInfoMedium.PYTHON_PACKAGE_INDEX `_ *medium* and the `SourceVersionType.INDEXED_VERSION `_ *version_type*, for which it reports the tracked package version as the *version* and the *version_guess*. Additionally, the pip source reports the package name through the ``package-name`` key of the *extra_data*. The pip source will report one SourceInfo instance for each of the packages discovered in tracking. """ import hashlib import os import re from buildstream import Source, SourceError from buildstream import utils # # Soft import of buildstream symbols only available in newer versions # # The BST_MIN_VERSION will provide a better user experience. # try: from buildstream import SourceInfoMedium, SourceVersionType except ImportError: pass _OUTPUT_DIRNAME = ".bst_pip_downloads" _PYPI_INDEX_URL = "https://pypi.org/simple/" # Used only for finding pip command _PYTHON_VERSIONS = [ "python", # when running in a venv, we might not have the exact version "python2.7", "python3.0", "python3.1", "python3.2", "python3.3", "python3.4", "python3.5", "python3.6", "python3.7", "python3.8", "python3.9", "python3.10", "python3.11", "python3.12", "python3", ] # List of allowed extensions taken from # https://docs.python.org/3/distutils/sourcedist.html. # Names of source distribution archives must be of the form # '%{package-name}-%{version}.%{extension}'. _SDIST_RE = re.compile( r"^([\w.-]+?)-((?:[\d.]+){2,})\.(?:tar|tar.bz2|tar.gz|tar.xz|tar.Z|zip)$", re.IGNORECASE, ) class PipSource(Source): # pylint: disable=attribute-defined-outside-init BST_MIN_VERSION = "2.5" # We need access to previous sources at track time to use requirements.txt # but not at fetch time as self.ref should contain sufficient information # for this plugin BST_REQUIRES_PREVIOUS_SOURCES_TRACK = True def configure(self, node): node.validate_keys(["url", "packages", "ref", "requirements-files"] + Source.COMMON_CONFIG_KEYS) self.ref = node.get_str("ref", None) self.original_url = node.get_str("url", _PYPI_INDEX_URL) self.index_url = self.translate_url(self.original_url) self.packages = node.get_str_list("packages", []) self.requirements_files = node.get_str_list("requirements-files", []) if not (self.packages or self.requirements_files): raise SourceError("{}: Either 'packages' or 'requirements-files' must be specified".format(self)) def preflight(self): # Try to find a pip version that spports download command self.host_pip = None for python in reversed(_PYTHON_VERSIONS): try: host_python = utils.get_host_tool(python) rc = self.call([host_python, "-m", "pip", "download", "--help"]) if rc == 0: self.host_pip = [host_python, "-m", "pip"] break except utils.ProgramNotFoundError: pass if self.host_pip is None: raise SourceError("{}: Unable to find a suitable pip command".format(self)) def get_unique_key(self): return [self.original_url, self.ref] def is_cached(self): return os.path.exists(self._mirror) and os.listdir(self._mirror) def get_ref(self): return self.ref def load_ref(self, node): self.ref = node.get_str("ref", None) def set_ref(self, ref, node): node["ref"] = self.ref = ref def track(self, previous_sources_dir): # pylint: disable=arguments-differ # XXX pip does not offer any public API other than the CLI tool so it # is not feasible to correctly parse the requirements file or to check # which package versions pip is going to install. # See https://pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program # for details. # As a result, we have to wastefully install the packages during track. with self.tempdir() as tmpdir: install_args = self.host_pip + [ "download", "--no-binary", ":all:", "--index-url", self.index_url, "--dest", tmpdir, ] for requirement_file in self.requirements_files: fpath = os.path.join(previous_sources_dir, requirement_file) install_args += ["-r", fpath] install_args += self.packages self.call(install_args, fail="Failed to install python packages") reqs = self._parse_sdist_names(tmpdir) return "\n".join(["{}=={}".format(pkg, ver) for pkg, ver in reqs]) def fetch(self): # pylint: disable=arguments-differ with self.tempdir() as tmpdir: packages = self.ref.strip().split("\n") package_dir = os.path.join(tmpdir, "packages") os.makedirs(package_dir) self.call( [ *self.host_pip, "download", "--no-binary", ":all:", "--index-url", self.index_url, "--dest", package_dir, *packages, ], fail="Failed to install python packages: {}".format(packages), ) # If the mirror directory already exists, assume that some other # process has fetched the sources before us and ensure that we do # not raise an error in that case. try: utils.move_atomic(package_dir, self._mirror) except utils.DirectoryExistsError: # Another process has beaten us and has fetched the sources # before us. pass except OSError as e: raise SourceError( "{}: Failed to move downloaded pip packages from '{}' to '{}': {}".format( self, package_dir, self._mirror, e ) ) from e def stage(self, directory): with self.timed_activity("Staging Python packages", silent_nested=True): utils.copy_files(self._mirror, os.path.join(directory, _OUTPUT_DIRNAME)) def collect_source_info(self): infos = [] packages_versions = self.ref.splitlines() for package_version in packages_versions: split = package_version.split("==") package = split[0] version = split[1] infos.append( self.create_source_info( self.index_url, SourceInfoMedium.PYTHON_PACKAGE_INDEX, SourceVersionType.INDEXED_VERSION, version, version_guess=version, extra_data={"package-name": package}, ) ) return infos # Directory where this source should stage its files # @property def _mirror(self): if not self.ref: return None return os.path.join( self.get_mirror_directory(), utils.url_directory_name(self.original_url), hashlib.sha256(self.ref.encode()).hexdigest(), ) # Parse names of downloaded source distributions # # Args: # basedir (str): Directory containing source distribution archives # # Returns: # (list): List of (package_name, version) tuples in sorted order # def _parse_sdist_names(self, basedir): reqs = [] for f in os.listdir(basedir): pkg = _match_package_name(f) if pkg is not None: reqs.append(pkg) return sorted(reqs) # Extract the package name and version of a source distribution # # Args: # filename (str): Filename of the source distribution # # Returns: # (tuple): A tuple of (package_name, version) # def _match_package_name(filename): pkg_match = _SDIST_RE.match(filename) if pkg_match is None: return None return pkg_match.groups() def setup(): return PipSource ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1772800547.7171528 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/0000755000175100017510000000000015152545044023212 5ustar00juergjuerg././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/PKG-INFO0000644000175100017510000000366515152545043024320 0ustar00juergjuergMetadata-Version: 2.4 Name: buildstream-plugins Version: 2.7.0 Summary: A collection of plugins for BuildStream. Home-page: https://buildstream.build Author: The Apache Software Foundation Author-email: dev@buildstream.apache.org License: Apache License Version 2.0 Project-URL: Documentation, https://apache.github.io/buildstream-plugins/ Project-URL: Source, https://github.com/apache/buildstream-plugins/ Project-URL: Tracker, https://github.com/apache/buildstream-plugins/issues Project-URL: Mailing List, https://lists.apache.org/list.html?dev@buildstream.apache.org Classifier: Environment :: Console Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: POSIX Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Programming Language :: Python :: 3.13 Classifier: Programming Language :: Python :: 3.14 Classifier: Topic :: Software Development :: Build Tools Description-Content-Type: text/x-rst; charset=UTF-8 License-File: LICENSE License-File: NOTICE Provides-Extra: cargo Requires-Dist: tomli; python_version < "3.11" and extra == "cargo" Dynamic: author Dynamic: author-email Dynamic: classifier Dynamic: description Dynamic: description-content-type Dynamic: home-page Dynamic: license Dynamic: license-file Dynamic: project-url Dynamic: provides-extra Dynamic: summary BuildStream Plugins =================== A collection of plugins for the `BuildStream `_ project. How to use plugins ------------------ Plugins must be declared by your BuildStream project.conf for use in your project. For instructions on how to load plugins in your BuildStream project, please consult the `plugin loading documentation `_ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/SOURCES.txt0000644000175100017510000000316315152545043025100 0ustar00juergjuerg.asf.yaml COMMITTERS.rst LICENSE MANIFEST.in NEWS NOTICE README.rst project.conf pyproject.toml setup.cfg setup.py requirements/mypy-requirements.txt requirements/plugin-requirements.txt requirements/test-requirements.txt src/buildstream_plugins/__init__.py src/buildstream_plugins.egg-info/PKG-INFO src/buildstream_plugins.egg-info/SOURCES.txt src/buildstream_plugins.egg-info/dependency_links.txt src/buildstream_plugins.egg-info/entry_points.txt src/buildstream_plugins.egg-info/not-zip-safe src/buildstream_plugins.egg-info/requires.txt src/buildstream_plugins.egg-info/top_level.txt src/buildstream_plugins/elements/__init__.py src/buildstream_plugins/elements/autotools.py src/buildstream_plugins/elements/autotools.yaml src/buildstream_plugins/elements/cmake.py src/buildstream_plugins/elements/cmake.yaml src/buildstream_plugins/elements/make.py src/buildstream_plugins/elements/make.yaml src/buildstream_plugins/elements/meson.py src/buildstream_plugins/elements/meson.yaml src/buildstream_plugins/elements/pip.py src/buildstream_plugins/elements/pip.yaml src/buildstream_plugins/elements/setuptools.py src/buildstream_plugins/elements/setuptools.yaml src/buildstream_plugins/sourcemirrors/__init__.py src/buildstream_plugins/sourcemirrors/gitlab_lfs_mirror.py src/buildstream_plugins/sourcemirrors/simple_mirror.py src/buildstream_plugins/sources/__init__.py src/buildstream_plugins/sources/_utils.py src/buildstream_plugins/sources/bzr.py src/buildstream_plugins/sources/cargo.py src/buildstream_plugins/sources/docker.py src/buildstream_plugins/sources/git.py src/buildstream_plugins/sources/patch.py src/buildstream_plugins/sources/pip.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/dependency_links.txt0000644000175100017510000000000115152545043027257 0ustar00juergjuerg ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/entry_points.txt0000644000175100017510000000142115152545043026505 0ustar00juergjuerg[buildstream.plugins.elements] autotools = buildstream_plugins.elements.autotools cmake = buildstream_plugins.elements.cmake make = buildstream_plugins.elements.make meson = buildstream_plugins.elements.meson pip = buildstream_plugins.elements.pip setuptools = buildstream_plugins.elements.setuptools [buildstream.plugins.sourcemirrors] gitlab_lfs_mirror = buildstream_plugins.sourcemirrors.gitlab_lfs_mirror simple_mirror = buildstream_plugins.sourcemirrors.simple_mirror [buildstream.plugins.sources] bzr = buildstream_plugins.sources.bzr cargo = buildstream_plugins.sources.cargo docker = buildstream_plugins.sources.docker git = buildstream_plugins.sources.git patch = buildstream_plugins.sources.patch pip = buildstream_plugins.sources.pip zip = buildstream_plugins.sources.zip ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/not-zip-safe0000644000175100017510000000000115152545043025437 0ustar00juergjuerg ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/requires.txt0000644000175100017510000000006015152545043025605 0ustar00juergjuerg [cargo] [cargo:python_version < "3.11"] tomli ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1772800547.0 buildstream_plugins-2.7.0/src/buildstream_plugins.egg-info/top_level.txt0000644000175100017510000000002415152545043025737 0ustar00juergjuergbuildstream_plugins