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
|
#
# Copyright (C) 2017 Codethink Limited
# Copyright (C) 2018 Bloomberg Finance LP
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser 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
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library. If not, see <http://www.gnu.org/licenses/>.
#
# Authors:
# Tristan Maat <tristan.maat@codethink.co.uk>
import os
from .. import utils
from ..sandbox import SandboxDummy
from .platform import Platform
from .._exceptions import PlatformError
class Linux(Platform):
def _setup_sandbox(self, force_sandbox):
sandbox_setups = {
'bwrap': self._setup_bwrap_sandbox,
'buildbox': self._setup_buildbox_sandbox,
'buildbox-run': self._setup_buildboxrun_sandbox,
'chroot': self._setup_chroot_sandbox,
'dummy': self._setup_dummy_sandbox,
}
preferred_sandboxes = [
'bwrap',
]
self._try_sandboxes(force_sandbox, sandbox_setups, preferred_sandboxes)
def __init__(self, force_sandbox=None):
super().__init__(force_sandbox=force_sandbox)
self._uid = os.geteuid()
self._gid = os.getegid()
# Set linux32 option
self.linux32 = None
def can_crossbuild(self, config):
host_arch = self.get_host_arch()
if ((config.build_arch == "x86-32" and host_arch == "x86-64") or
(config.build_arch == "aarch32" and host_arch == "aarch64")):
if self.linux32 is None:
try:
utils.get_host_tool('linux32')
self.linux32 = True
except utils.ProgramNotFoundError:
self.linux32 = False
return self.linux32
return False
################################################
# Private Methods #
################################################
# Dummy sandbox methods
@staticmethod
def _check_dummy_sandbox_config(config):
return True
def _create_dummy_sandbox(self, *args, **kwargs):
dummy_reasons = " and ".join(self.dummy_reasons)
kwargs['dummy_reason'] = dummy_reasons
return SandboxDummy(*args, **kwargs)
def _setup_dummy_sandbox(self):
self.check_sandbox_config = Linux._check_dummy_sandbox_config
self.create_sandbox = self._create_dummy_sandbox
return True
# Bubble-wrap sandbox methods
def _check_sandbox_config_bwrap(self, config):
from ..sandbox._sandboxbwrap import SandboxBwrap
return SandboxBwrap.check_sandbox_config(self, config)
def _create_bwrap_sandbox(self, *args, **kwargs):
from ..sandbox._sandboxbwrap import SandboxBwrap
kwargs['linux32'] = self.linux32
return SandboxBwrap(*args, **kwargs)
def _setup_bwrap_sandbox(self):
from ..sandbox._sandboxbwrap import SandboxBwrap
# This function should only be called once.
# but if it does eg, in the tests we want to
# reset the sandbox checks
SandboxBwrap._have_good_bwrap = None
self._check_sandbox(SandboxBwrap)
self.check_sandbox_config = self._check_sandbox_config_bwrap
self.create_sandbox = self._create_bwrap_sandbox
return True
# Chroot sandbox methods
def _check_sandbox_config_chroot(self, config):
from ..sandbox._sandboxchroot import SandboxChroot
return SandboxChroot.check_sandbox_config(self, config)
@staticmethod
def _create_chroot_sandbox(*args, **kwargs):
from ..sandbox._sandboxchroot import SandboxChroot
return SandboxChroot(*args, **kwargs)
def _setup_chroot_sandbox(self):
from ..sandbox._sandboxchroot import SandboxChroot
self._check_sandbox(SandboxChroot)
self.check_sandbox_config = self._check_sandbox_config_chroot
self.create_sandbox = Linux._create_chroot_sandbox
return True
# Buildbox sandbox methods
def _check_sandbox_config_buildbox(self, config):
from ..sandbox._sandboxbuildbox import SandboxBuildBox
return SandboxBuildBox.check_sandbox_config(self, config)
@staticmethod
def _create_buildbox_sandbox(*args, **kwargs):
from ..sandbox._sandboxbuildbox import SandboxBuildBox
if kwargs.get('allow_real_directory'):
raise PlatformError("The BuildBox Sandbox does not support real directories.",
reason="You are using BuildBox sandbox because BST_FORCE_SANBOX=buildbox")
return SandboxBuildBox(*args, **kwargs)
def _setup_buildbox_sandbox(self):
from ..sandbox._sandboxbuildbox import SandboxBuildBox
self._check_sandbox(SandboxBuildBox)
self.check_sandbox_config = self._check_sandbox_config_buildbox
self.create_sandbox = self._create_buildbox_sandbox
return True
# Buildbox run sandbox methods
def _check_sandbox_config_buildboxrun(self, config):
from ..sandbox._sandboxbuildboxrun import SandboxBuildBoxRun
return SandboxBuildBoxRun.check_sandbox_config(self, config)
@staticmethod
def _create_buildboxrun_sandbox(*args, **kwargs):
from ..sandbox._sandboxbuildboxrun import SandboxBuildBoxRun
return SandboxBuildBoxRun(*args, **kwargs)
def _setup_buildboxrun_sandbox(self):
from ..sandbox._sandboxbuildboxrun import SandboxBuildBoxRun
self._check_sandbox(SandboxBuildBoxRun)
self.check_sandbox_config = self._check_sandbox_config_buildboxrun
self.create_sandbox = self._create_buildboxrun_sandbox
return True
|
