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
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
PSTAGE2_MANIFESTS = "${TMPDIR}/pstagelogs"
PSTAGE2_MANFILEPREFIX = "${PSTAGE2_MANIFESTS}/manifest-${PSTAGE2_PKGARCH}-${PN}"
PSTAGE2_PKGARCH = "${BASE_PACKAGE_ARCH}"
PSTAGE2_PKGVERSION = "${PV}-${PR}"
PSTAGE2_PKGPN = "${@bb.data.expand('staging-${PN}-${MULTIMACH_ARCH}${TARGET_VENDOR}-${TARGET_OS}', d).replace('_', '-')}"
PSTAGE2_PKGNAME = "${PSTAGE2_PKGPN}_${PSTAGE2_PKGVERSION}_${PSTAGE2_PKGARCH}"
PSTAGE2_EXTRAPATH ?= ""
PSTAGE2_PKGPATH = "${DISTRO}/${OELAYOUT_ABI}${PSTAGE2_EXTRAPATH}"
PSTAGE2_PKG = "${PSTAGE_DIR}2/${PSTAGE2_PKGPATH}/${PSTAGE2_PKGNAME}"
PSTAGE2_SCAN_CMD ?= "find ${PSTAGE2_BUILDDIR} \( -name "*.la" -o -name "*-config" \) -type f"
python () {
if bb.data.inherits_class('native', d):
bb.data.setVar('PSTAGE2_PKGARCH', bb.data.getVar('BUILD_ARCH', d), d)
elif bb.data.inherits_class('cross', d) or bb.data.inherits_class('crosssdk', d):
bb.data.setVar('PSTAGE2_PKGARCH', bb.data.expand("${BUILD_ARCH}_${BASE_PACKAGE_ARCH}", d), d)
elif bb.data.inherits_class('nativesdk', d):
bb.data.setVar('PSTAGE2_PKGARCH', bb.data.expand("${SDK_ARCH}", d), d)
elif bb.data.inherits_class('cross-canadian', d):
bb.data.setVar('PSTAGE2_PKGARCH', bb.data.expand("${SDK_ARCH}_${BASE_PACKAGE_ARCH}", d), d)
# These classes encode staging paths into their scripts data so can only be
# reused if we manipulate the paths
if bb.data.inherits_class('native', d) or bb.data.inherits_class('cross', d) or bb.data.inherits_class('sdk', d) or bb.data.inherits_class('crosssdk', d):
scan_cmd = "grep -Irl ${STAGING_DIR} ${PSTAGE2_BUILDDIR}"
bb.data.setVar('PSTAGE2_SCAN_CMD', scan_cmd, d)
for task in (bb.data.getVar('SSTATETASKS', d, True) or "").split():
funcs = bb.data.getVarFlag(task, 'prefuncs', d) or ""
funcs = "sstate_task_prefunc " + funcs
bb.data.setVarFlag(task, 'prefuncs', funcs, d)
funcs = bb.data.getVarFlag(task, 'postfuncs', d) or ""
funcs = "sstate_task_postfunc " + funcs
bb.data.setVarFlag(task, 'postfuncs', funcs, d)
}
def sstate_init(name, d):
ss = {}
ss['name'] = name
ss['dirs'] = []
ss['plaindirs'] = []
ss['lockfiles'] = []
return ss
def sstate_state_fromvars(d):
task = bb.data.getVar('BB_CURRENTTASK', d, True)
if not task:
bb.fatal("sstate code running without task context?!")
task = task.replace("_setscene", "")
name = bb.data.expand(bb.data.getVarFlag("do_" + task, 'sstate-name', d), d)
inputs = (bb.data.expand(bb.data.getVarFlag("do_" + task, 'sstate-inputdirs', d) or "", d)).split()
outputs = (bb.data.expand(bb.data.getVarFlag("do_" + task, 'sstate-outputdirs', d) or "", d)).split()
plaindirs = (bb.data.expand(bb.data.getVarFlag("do_" + task, 'sstate-plaindirs', d) or "", d)).split()
lockfiles = (bb.data.expand(bb.data.getVarFlag("do_" + task, 'sstate-lockfile', d) or "", d)).split()
if not name or len(inputs) != len(outputs):
bb.fatal("sstate variables not setup correctly?!")
ss = sstate_init(name, d)
for i in range(len(inputs)):
sstate_add(ss, inputs[i], outputs[i], d)
ss['lockfiles'] = lockfiles
ss['plaindirs'] = plaindirs
return ss
def sstate_add(ss, source, dest, d):
srcbase = os.path.basename(source)
ss['dirs'].append([srcbase, source, dest])
return ss
def sstate_install(ss, d):
import oe.path
sharedfiles = []
shareddirs = []
bb.mkdirhier(bb.data.expand("${PSTAGE2_MANIFESTS}", d))
manifest = bb.data.expand("${PSTAGE2_MANFILEPREFIX}.%s" % ss['name'], d)
if os.access(manifest, os.R_OK):
bb.fatal("Package already staged (%s)?!" % manifest)
locks = []
for lock in ss['lockfiles']:
locks.append(bb.utils.lockfile(lock))
for state in ss['dirs']:
oe.path.copytree(state[1], state[2])
for walkroot, dirs, files in os.walk(state[1]):
for file in files:
srcpath = os.path.join(walkroot, file)
dstpath = srcpath.replace(state[1], state[2])
bb.debug(2, "Staging %s to %s" % (srcpath, dstpath))
sharedfiles.append(dstpath)
for dir in dirs:
dir = os.path.join(state[2], dir)
if not dir.endswith("/"):
dir = dir + "/"
shareddirs.append(dir)
f = open(manifest, "w")
for file in sharedfiles:
f.write(file + "\n")
# We want to ensure that directories appear at the end of the manifest
# so that when we test to see if they should be deleted any contents
# added by the task will have been removed first.
for dir in shareddirs:
f.write(dir + "\n")
f.close()
for lock in locks:
bb.utils.unlockfile(lock)
def sstate_installpkg(ss, d):
import oe.path
pstageinst = bb.data.expand("${WORKDIR}/pstage-install-%s/" % ss['name'], d)
pstagepkg = bb.data.getVar('PSTAGE2_PKG', d, True) + '_' + ss['name'] + ".tgz"
if not os.path.exists(pstagepkg):
pstaging_fetch(pstagepkg, d)
if not os.path.isfile(pstagepkg):
bb.note("Staging package %s does not exist" % pstagepkg)
return False
sstate_clean(ss, d)
bb.data.setVar('PSTAGE2_INSTDIR', pstageinst, d)
bb.data.setVar('PSTAGE2_PKG', pstagepkg, d)
bb.build.exec_func('sstate_unpack_package', d)
# Fixup hardcoded paths
fixmefn = pstageinst + "fixmepath"
if os.path.isfile(fixmefn):
staging = bb.data.getVar('STAGING_DIR', d, True)
fixmefd = open(fixmefn, "r")
fixmefiles = fixmefd.readlines()
fixmefd.close()
for file in fixmefiles:
os.system("sed -i -e s:FIXMESTAGINGDIR:%s:g %s" % (staging, pstageinst + file))
for state in ss['dirs']:
if os.path.exists(state[1]):
oe.path.remove(state[1])
oe.path.copytree(pstageinst + state[0], state[1])
sstate_install(ss, d)
for plain in ss['plaindirs']:
bb.mkdirhier(pstageinst + plain)
oe.path.copytree(pstageinst + plain, bb.data.getVar('WORKDIR', d, True) + plain)
return True
def sstate_clean_manifest(manifest, d):
import oe.path
if not os.path.exists(manifest):
return
mfile = open(manifest)
entries = mfile.readlines()
mfile.close()
for entry in entries:
entry = entry.strip()
if entry.endswith("/"):
if os.path.exists(entry) and len(os.listdir(entry)) == 0:
os.rmdir(entry)
else:
oe.path.remove(entry)
oe.path.remove(manifest)
def sstate_clean(ss, d):
manifest = bb.data.expand("${PSTAGE2_MANFILEPREFIX}.%s" % ss['name'], d)
locks = []
for lock in ss['lockfiles']:
locks.append(bb.utils.lockfile(lock))
sstate_clean_manifest(manifest, d)
for lock in locks:
bb.utils.unlockfile(lock)
python sstate_cleanall() {
import fnmatch
bb.note("Removing %s from staging" % bb.data.getVar('PN', d, True))
manifest_dir = bb.data.getVar('PSTAGE2_MANIFESTS', d, True)
manifest_pattern = bb.data.expand("manifest-${PN}.*", d)
for manifest in (os.listdir(manifest_dir)):
if fnmatch.fnmatch(manifest, manifest_pattern):
sstate_clean_manifest(manifest_dir + "/" + manifest, d)
}
do_clean[postfuncs] += "sstate_cleanall"
do_clean[dirs] += "${PSTAGE2_MANIFESTS}"
def sstate_package(ss, d):
import oe.path
pstagebuild = bb.data.expand("${WORKDIR}/pstage-build-%s/" % ss['name'], d)
pstagepkg = bb.data.getVar('PSTAGE2_PKG', d, True) + '_'+ ss['name'] + ".tgz"
bb.mkdirhier(pstagebuild)
bb.mkdirhier(os.path.dirname(pstagepkg))
for state in ss['dirs']:
srcbase = state[0].rstrip("/").rsplit('/', 1)[0]
oe.path.copytree(state[1], pstagebuild + state[0])
for walkroot, dirs, files in os.walk(state[1]):
for file in files:
srcpath = os.path.join(walkroot, file)
dstpath = srcpath.replace(state[1], pstagebuild + state[0])
bb.debug(2, "Preparing %s for packaging at %s" % (srcpath, dstpath))
workdir = bb.data.getVar('WORKDIR', d, True)
for plain in ss['plaindirs']:
pdir = plain.replace(workdir, pstagebuild)
bb.mkdirhier(plain)
bb.mkdirhier(pdir)
oe.path.copytree(plain, pdir)
bb.data.setVar('PSTAGE2_BUILDDIR', pstagebuild, d)
bb.data.setVar('PSTAGE2_PKG', pstagepkg, d)
bb.build.exec_func('sstate_create_package', d)
return
def pstaging_fetch(pstagepkg, d):
import bb.fetch
# only try and fetch if the user has configured a mirror
if bb.data.getVar('PSTAGE_MIRROR', d) != "":
# Copy the data object and override DL_DIR and SRC_URI
pd = d.createCopy()
dldir = bb.data.expand("${PSTAGE_DIR}/${PSTAGE_PKGPATH}", pd)
mirror = bb.data.expand("${PSTAGE_MIRROR}/${PSTAGE_PKGPATH}/", pd)
srcuri = mirror + os.path.basename(pstagepkg)
bb.data.setVar('DL_DIR', dldir, pd)
bb.data.setVar('SRC_URI', srcuri, pd)
# Try a fetch from the pstage mirror, if it fails just return and
# we will build the package
try:
bb.fetch.init([srcuri], pd)
bb.fetch.go(pd, [srcuri])
except:
return
def sstate_setscene(d):
shared_state = sstate_state_fromvars(d)
accelerate = sstate_installpkg(shared_state, d)
if not accelerate:
raise bb.build.FuncFailed("No suitable staging package found")
python sstate_task_prefunc () {
shared_state = sstate_state_fromvars(d)
sstate_clean(shared_state, d)
}
python sstate_task_postfunc () {
shared_state = sstate_state_fromvars(d)
sstate_install(shared_state, d)
sstate_package(shared_state, d)
}
#
# Shell function to generate a pstage package from a directory
# set as PSTAGE2_BUILDDIR
#
sstate_create_package () {
# Need to remove hardcoded paths and fix these when we install the
# staging packages.
for i in `${PSTAGE2_SCAN_CMD}` ; do \
sed -i -e s:${STAGING_DIR}:FIXMESTAGINGDIR:g $i
echo $i | sed -e 's:${PSTAGE2_BUILDDIR}::' >> ${PSTAGE2_BUILDDIR}fixmepath
done
cd ${PSTAGE2_BUILDDIR}
tar -cvzf ${PSTAGE2_PKG} *
}
#
# Shell function to decompress and prepare a package for installation
#
sstate_unpack_package () {
mkdir -p ${PSTAGE2_INSTDIR}
cd ${PSTAGE2_INSTDIR}
tar -xvzf ${PSTAGE2_PKG}
}
|
