1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
# cerbero - a multi-platform build system for Open Source software
# Copyright (C) 2022 Nirbheek Chauhan <nirbheek@centricular.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
import os
import stat
import shutil
from urllib.parse import urlparse
from cerbero.bootstrap import BootstrapperBase
from cerbero.utils import shell
from cerbero.utils import messages as m
from cerbero.enums import Platform, Architecture
class RustBootstrapper(BootstrapperBase):
"""
A class for installing a self-contained Rust and Cargo installation inside
Cerbero's home dir
"""
SERVER = 'https://static.rust-lang.org'
RUSTUP_VERSION = '1.27.0'
RUST_VERSION = '1.77.0'
RUSTUP_URL_TPL = '{server}/rustup/archive/{version}/{triple}/rustup-init{exe_suffix}'
RUSTUP_NAME_TPL = 'rustup-init-{version}-{triple}{exe_suffix}'
CHANNEL_URL_TPL = '{server}/dist/channel-rust-{version}.toml'
COMPONENTS = ('cargo', 'rustc', 'rust-std', 'llvm-tools-preview')
# Update from https://pypi.org/project/tomli/#files
TOMLI_URL = 'https://files.pythonhosted.org/packages/c0/3f/d7af728f075fb08564c5949a9c95e44352e23dee646869fa104a3b2060a3/tomli-2.0.1.tar.gz'
DOWNLOAD_CHECKSUMS = {
# Rust packages metadata
'channel-rust-1.77.0.toml': 'faccaa01dda45fc2956bcfd4da0cf76e52104d3b1862ddd4eb7c4159a18e49cf',
# Tomli Python module
'tomli-2.0.1.tar.gz': 'de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f',
# Rustup
'rustup-init-1.27.0-aarch64-unknown-linux-gnu': '76cd420cb8a82e540025c5f97bda3c65ceb0b0661d5843e6ef177479813b0367',
'rustup-init-1.27.0-x86_64-unknown-linux-gnu': 'a3d541a5484c8fa2f1c21478a6f6c505a778d473c21d60a18a4df5185d320ef8',
'rustup-init-1.27.0-aarch64-apple-darwin': 'c30c180297a0053dcb8932ed43d365f0c9005abd847375f7ed5799a761ea81e5',
'rustup-init-1.27.0-x86_64-apple-darwin': '02a2d8501a567bfd43e8e0ee18ba7af0c09c84997ae7510e0f620c46293f32e0',
'rustup-init-1.27.0-i686-pc-windows-msvc.exe': '6f9ad11abd642a7cba4ee6f386b84d56045ee12f921c5d9832913d937e0f3547',
'rustup-init-1.27.0-x86_64-pc-windows-msvc.exe': '743bbd6b5a622ddc5c5234ce0fd3eab6ca74499a119fbf484dc55755a6a7e443',
'rustup-init-1.27.0-i686-pc-windows-gnu.exe': '5d45dc8f088a04c312a451c9b7d6fc49b3c68f3a85819cef2e0da020a9b75637',
'rustup-init-1.27.0-x86_64-pc-windows-gnu.exe': '32e9128a82ac130043012463ca5f9cb507c349a3f16e3c2b98a3f7a32e294e59',
}
# The triple for the build platform/arch
build_triple = None
# The triples for the target platform/archs for the current cerbero config.
# There will be more than one when doing universal builds.
target_triples = None
# Downloaded rustup path
rustup = None
# Downloadad rust channel
channel = None
def __init__(self, config, offline):
super().__init__(config, offline)
self.offline = offline
self.build_triple = self.config.rust_build_triple
self.target_triples = self.config.rust_target_triples
if self.config.platform == Platform.WINDOWS:
# On Windows, build-tools always use MSVC so we need to always
# bootstrap $arch-windows-msvc
bs_triple = self.config.rust_triple(self.config.arch, self.config.platform, True)
if bs_triple not in self.target_triples:
self.target_triples.append(bs_triple)
# rustup-init wants to always install both 64-bit and 32-bit
# toolchains, so ensure that we fetch and install both
archs = {Architecture.X86_64, Architecture.X86}
other_arch = (archs - {self.config.arch}).pop()
arch_triple = self.config.rust_triple(other_arch, self.config.platform, self.config.variants.visualstudio)
if arch_triple not in self.target_triples:
self.target_triples.append(arch_triple)
self.fetch_urls = self.get_fetch_urls()
self.fetch_urls_func = self.get_more_fetch_urls
self.extract_steps = []
# Need to extract our own toml library if the system doesn't provide
# one already
if not self.config.find_toml_module(system_only=True):
self.extract_steps += [(self.TOMLI_URL, True, self.config.rust_prefix)]
def get_fetch_urls(self):
"""Get Rustup and Rust channel URLs"""
urls = []
m = {
'server': self.SERVER,
'version': self.RUSTUP_VERSION,
'triple': self.build_triple,
'exe_suffix': self.config.exe_suffix,
}
# Rustup
url = self.RUSTUP_URL_TPL.format(**m)
name = self.RUSTUP_NAME_TPL.format(**m)
checksum = self.DOWNLOAD_CHECKSUMS[name]
urls.append((url, name, checksum))
self.rustup = os.path.join(self.config.local_sources, name)
# Rust channel
m['version'] = self.RUST_VERSION
url = self.CHANNEL_URL_TPL.format(**m)
# We download channel-rust-{version}.toml and rename it to
# channel-rust-stable.toml to fool rustup into thinking that this is
# the latest stable release. That way when we upgrade the toolchain,
# rustup will automatically remove the older toolchain, which it
# wouldn't do if we installed a specific version.
path = urlparse(url).path
f = os.path.basename(path)
self.channel = os.path.join(self.config.local_sources, path[1:])
checksum = self.DOWNLOAD_CHECKSUMS[f]
urls.append((url, path[1:], checksum))
for each in ('.sha256', '.asc'):
urls.append((url + each, path[1:] + each, False))
if not self.config.find_toml_module(system_only=True):
# Need the tomli python module to be able to parse the channel TOML file
checksum = self.DOWNLOAD_CHECKSUMS[os.path.basename(self.TOMLI_URL)]
urls.append((self.TOMLI_URL, None, checksum))
return urls
async def get_more_fetch_urls(self):
# Extract tomli (if specified) and cargo-c, remove them from extract steps
# We need tomli now, and we need cargo-c in the function we call next
await self.extract()
self.extract_steps = []
if not self.config.find_toml_module(system_only=True):
# tomli-<version>.tar.gz
basename = os.path.basename(self.TOMLI_URL)
# tomli-<version>.tar
basename = os.path.splitext(basename)[0]
# tomli-<version>
basename = os.path.splitext(basename)[0]
extracted_path = os.path.join(self.config.rust_prefix, basename)
if os.path.exists(self.config.tomllib_path):
shutil.rmtree(self.config.tomllib_path)
os.replace(extracted_path, self.config.tomllib_path)
tomllib = self.config.find_toml_module()
with open(self.channel, 'r', encoding='utf-8') as f:
channel_data = tomllib.loads(f.read())
def get_entry_urls(entry):
url = entry['xz_url']
name = urlparse(url).path[1:]
sha = entry['xz_hash']
yield (url, name, sha)
yield (url + '.sha256', name + '.sha256', False)
yield (url + '.asc', name + '.asc', False)
urls = []
# Need the toolchain for the build machine first
entry = channel_data['pkg']['rust']['target'][self.build_triple]
urls += list(get_entry_urls(entry))
# Components for build machine
for c in self.COMPONENTS:
entry = channel_data['pkg'][c]['target'][self.build_triple]
urls += list(get_entry_urls(entry))
# And then maybe also rust-std for the target machine
for triple in self.target_triples:
if triple != self.build_triple:
entry = channel_data['pkg']['rust-std']['target'][triple]
urls += list(get_entry_urls(entry))
return (urls, self.install_toolchain_for_cargoc_fetch)
async def install_toolchain_for_cargoc_fetch(self):
m.action('Installing Rust toolchain so cargo-c.recipe can fetch deps')
await self.install_toolchain()
return ([], None)
def get_rustup_env(self):
rustup_env = self.config.env.copy()
rustup_env['CARGO_HOME'] = self.config.env['CARGO_HOME']
rustup_env['RUSTUP_HOME'] = self.config.env['RUSTUP_HOME']
# Set to local file:// URLs to support offline mode
rustup_env['RUSTUP_UPDATE_ROOT'] = 'file://{}/rustup'.format(self.config.local_sources)
rustup_env['RUSTUP_DIST_SERVER'] = 'file://{}'.format(self.config.local_sources)
return rustup_env
async def install_toolchain(self):
"""
Run rustup to install the downloaded toolchain. We pretend that
RUST_VERSION is the latest stable release. That way when we upgrade the
toolchain, rustup will automatically remove the older toolchain, which
it wouldn't do if we installed a specific version.
"""
# Install Rust toolchain with rustup-init
st = os.stat(self.rustup)
os.chmod(self.rustup, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
rustup_args = [
self.rustup,
'-y',
'-v',
'--no-modify-path',
'--default-host',
self.build_triple,
'--profile',
'minimal',
'--component',
'llvm-tools-preview',
]
for triple in self.target_triples:
rustup_args += ['--target', triple]
rustup_env = self.get_rustup_env()
for suffix in ('', '.asc', '.sha256'):
stable_channel = f'{os.path.dirname(self.channel)}/channel-rust-stable.toml'
shutil.copyfile(self.channel + suffix, stable_channel + suffix)
if os.path.exists(self.config.rustup_home):
shutil.rmtree(self.config.rustup_home)
# Use async_call_output to discard stdout which contains messages that will confuse the user
await shell.async_call_output(rustup_args, cpu_bound=False, env=rustup_env)
m.message('Rust toolchain v{} installed at {}'.format(self.RUST_VERSION, self.config.rust_prefix))
async def start(self, jobs=0):
await self.install_toolchain()
|
