296 lines
11 KiB
Python
296 lines
11 KiB
Python
|
|
import sys
|
|
from collections import OrderedDict
|
|
from .buildenv import *
|
|
|
|
from .platforms import PlatformInfo
|
|
from .utils import remove_duplicates, run_command, StopBuild, Context
|
|
from .dependencies import Dependency
|
|
from .packages import PACKAGE_NAME_MAPPERS
|
|
from .versions import base_deps_versions
|
|
from ._global import (
|
|
neutralEnv, option,
|
|
add_target_step, get_target_step, target_steps,
|
|
backend)
|
|
from . import _global
|
|
from .dependencies.base import (
|
|
Source,
|
|
Builder,
|
|
ReleaseDownload,
|
|
GitClone,
|
|
MesonBuilder,
|
|
CMakeBuilder,
|
|
QMakeBuilder,
|
|
MakeBuilder,
|
|
SCRIPT_DIR)
|
|
import json
|
|
from shutil import copyfile
|
|
from urllib.parse import urlparse
|
|
from urllib.request import urlopen
|
|
import json
|
|
|
|
MANIFEST = {
|
|
'app-id': 'org.kiwix.desktop',
|
|
'runtime': 'org.kde.Platform',
|
|
'runtime-version': base_deps_versions['org.kde'],
|
|
'sdk': 'org.kde.Sdk',
|
|
'command': 'kiwix-desktop',
|
|
'rename-icon': 'kiwix-desktop',
|
|
'finish-args': [
|
|
'--socket=wayland',
|
|
'--socket=x11',
|
|
'--share=network',
|
|
'--share=ipc',
|
|
'--device=dri',
|
|
'--socket=pulseaudio',
|
|
],
|
|
'cleanup': [
|
|
'/include',
|
|
'/lib/pkgconfig',
|
|
'/lib/cmake',
|
|
'/lib/*.la',
|
|
'/bin/curl',
|
|
'/bin/copydatabase',
|
|
'/bin/kiwix-compile-resources',
|
|
'/bin/kiwix-manage',
|
|
'/bin/kiwix-read',
|
|
'/bin/kiwix-search',
|
|
'/bin/quest',
|
|
'/bin/simple*',
|
|
'/bin/xapian-*',
|
|
'/share/aclocal',
|
|
'/share/doc',
|
|
'/share/man'
|
|
]
|
|
}
|
|
|
|
GET_REF_URL_API_TEMPLATE = 'https://api.github.com/repos{repo}/git/refs/tags/{ref}'
|
|
|
|
class FlatpakBuilder:
|
|
def __init__(self):
|
|
self._targets = {}
|
|
PlatformInfo.get_platform('neutral', self._targets)
|
|
self.platform = PlatformInfo.get_platform('flatpak', self._targets)
|
|
if neutralEnv('distname') not in self.platform.compatible_hosts:
|
|
print(('ERROR: The target platform {} cannot be build on host {}.\n'
|
|
'Select another target platform or change your host system.'
|
|
).format(self.platform.name, neutralEnv('distname')))
|
|
self.targetDefs = self.platform.add_targets(option('target'), self._targets)
|
|
|
|
def finalize_target_steps(self):
|
|
steps = []
|
|
for targetDef in self.targetDefs:
|
|
steps += self.order_steps(targetDef)
|
|
steps = list(remove_duplicates(steps))
|
|
|
|
for pltName in PlatformInfo.all_running_platforms:
|
|
plt = PlatformInfo.all_platforms[pltName]
|
|
for tlcName in plt.toolchain_names:
|
|
tlc = Dependency.all_deps[tlcName]
|
|
src_plt_step = ('source', tlcName)
|
|
add_target_step(src_plt_step, self._targets[src_plt_step])
|
|
blt_plt_step = ('neutral' if tlc.neutral else pltName, tlcName)
|
|
add_target_step(blt_plt_step, self._targets[blt_plt_step])
|
|
|
|
for dep in steps:
|
|
add_target_step(dep, self._targets[dep])
|
|
self.instanciate_steps()
|
|
|
|
def order_steps(self, targetDef):
|
|
_targets = dict(self._targets)
|
|
yield from self.order_dependencies(targetDef, _targets)
|
|
|
|
def order_dependencies(self, targetDef, targets):
|
|
targetPlatformName, targetName = targetDef
|
|
if targetPlatformName == 'source':
|
|
# Do not try to order sources, they will be added as dep by the
|
|
# build step two lines later.
|
|
return
|
|
try:
|
|
target = targets.pop(targetDef)
|
|
except KeyError:
|
|
return
|
|
|
|
targetPlatform = PlatformInfo.get_platform(targetPlatformName)
|
|
for dep in target.get_dependencies(targetPlatform, True):
|
|
if isinstance(dep, tuple):
|
|
depPlatform, depName = dep
|
|
else:
|
|
depPlatform, depName = targetPlatformName, dep
|
|
if (depPlatform, depName) in targets:
|
|
yield from self.order_dependencies((depPlatform, depName), targets)
|
|
yield ('source', targetName)
|
|
yield targetDef
|
|
|
|
def instanciate_steps(self):
|
|
for stepDef in list(target_steps()):
|
|
stepPlatform, stepName = stepDef
|
|
stepClass = Dependency.all_deps[stepName]
|
|
if stepPlatform == 'source':
|
|
source = get_target_step(stepDef)(stepClass)
|
|
add_target_step(stepDef, source)
|
|
else:
|
|
source = get_target_step(stepName, 'source')
|
|
env = PlatformInfo.get_platform(stepPlatform).buildEnv
|
|
builder = get_target_step(stepDef)(stepClass, source, env)
|
|
add_target_step(stepDef, builder)
|
|
|
|
def configure(self):
|
|
steps = remove_duplicates(target_steps())
|
|
modules = OrderedDict()
|
|
for stepDef in steps:
|
|
module = modules.setdefault(stepDef[1], {})
|
|
module['name'] = stepDef[1]
|
|
if stepDef[0] == 'source':
|
|
source = get_target_step(stepDef)
|
|
if getattr(source, 'flatpak_no_autogen', False):
|
|
module['no-autogen'] = True
|
|
module_sources = module.setdefault('sources', [])
|
|
if isinstance(source, ReleaseDownload):
|
|
src = {
|
|
'type': 'archive',
|
|
'sha256': source.archive.sha256,
|
|
'url': source.archive.url
|
|
}
|
|
if hasattr(source, 'flatpak_dest'):
|
|
src['dest'] = source.flatpak_dest
|
|
module_sources.append(src)
|
|
elif isinstance(source, GitClone):
|
|
src = {
|
|
'type': 'git',
|
|
'url': source.git_remote,
|
|
'tag': source.git_ref
|
|
}
|
|
try:
|
|
parsed = urlparse(source.git_remote)
|
|
if parsed.hostname == 'github.com':
|
|
repo = parsed.path[:-4]
|
|
api_url = GET_REF_URL_API_TEMPLATE.format(
|
|
repo = repo,
|
|
ref = source.git_ref)
|
|
with urlopen(api_url) as r:
|
|
ret = json.loads(r.read())
|
|
src['commit'] = ret['object']['sha']
|
|
except:
|
|
pass
|
|
module_sources.append(src)
|
|
for p in getattr(source, 'patches', []):
|
|
patch = {
|
|
'type': 'patch',
|
|
'path': 'patches/' + p
|
|
}
|
|
module_sources.append(patch)
|
|
|
|
if hasattr(source, 'flatpak_command'):
|
|
command = {
|
|
'type': 'shell',
|
|
'commands': [source.flatpak_command]
|
|
}
|
|
module_sources.append(command)
|
|
|
|
else:
|
|
builder = get_target_step(stepDef)
|
|
builder.set_flatpak_buildsystem(module)
|
|
print(module['name'])
|
|
|
|
manifest = MANIFEST.copy()
|
|
modules = [m for m in modules.values() if m.get('sources')]
|
|
for m in modules:
|
|
temp = m['sources']
|
|
del m['sources']
|
|
m['sources'] = temp
|
|
manifest['modules'] = modules
|
|
manifest_name = "{}.json".format(MANIFEST['app-id'])
|
|
manifest_path = pj(self.platform.buildEnv.build_dir, manifest_name)
|
|
with open(manifest_path, 'w') as f:
|
|
f.write(json.dumps(manifest, indent=4))
|
|
|
|
def copy_patches(self):
|
|
sourceDefs = (tDef for tDef in target_steps() if tDef[0] == 'source')
|
|
for sourceDef in sourceDefs:
|
|
source = get_target_step(sourceDef)
|
|
if not hasattr(source, 'patches'):
|
|
continue
|
|
for p in source.patches:
|
|
path = pj(SCRIPT_DIR, 'patches', p)
|
|
os.makedirs(pj(self.platform.buildEnv.build_dir, 'patches'), exist_ok=True)
|
|
dest = pj(self.platform.buildEnv.build_dir, 'patches', p)
|
|
copyfile(path, dest)
|
|
|
|
|
|
def build(self):
|
|
log = pj(self.platform.buildEnv.log_dir, 'cmd_build_flatpak.log')
|
|
context = Context('build', log, False)
|
|
command = "flatpak-builder --user --ccache --force-clean --repo=repo builddir {id}.json"
|
|
command = command.format(id = MANIFEST['app-id'])
|
|
try:
|
|
run_command(command, self.platform.buildEnv.build_dir, context, env=self.platform.get_env())
|
|
context._finalise()
|
|
except subprocess.CalledProcessError:
|
|
with open(log, 'r') as f:
|
|
print(f.read())
|
|
raise StopBuild()
|
|
|
|
def bundle(self):
|
|
log = pj(self.platform.buildEnv.log_dir, 'cmd_bundle_flatpak.log')
|
|
context = Context('bundle', log, False)
|
|
command = "flatpak build-bundle repo {id}.flatpak {id}"
|
|
command = command.format(id = MANIFEST['app-id'])
|
|
try:
|
|
run_command(command, self.platform.buildEnv.build_dir, context, env=self.platform.get_env())
|
|
context._finalise()
|
|
except subprocess.CalledProcessError:
|
|
with open(log, 'r') as f:
|
|
print(f.read())
|
|
raise StopBuild()
|
|
|
|
|
|
def _get_packages(self):
|
|
package_name_mapper = PACKAGE_NAME_MAPPERS.get('flatpak', {})
|
|
|
|
to_drop = []
|
|
for builderDef in self._targets:
|
|
platformName, builderName = builderDef
|
|
packages = package_name_mapper.get(builderName)
|
|
if packages:
|
|
to_drop.append(builderDef)
|
|
for dep in to_drop:
|
|
del self._targets[dep]
|
|
|
|
def run(self):
|
|
try:
|
|
# This is a small hack, we don't need the list of packages to
|
|
# install in a flatpak sdk, but _get_packages() will drop the
|
|
# dependencies we already have in the sdk.
|
|
self._get_packages()
|
|
self.finalize_target_steps()
|
|
print("[SETUP PLATFORMS]")
|
|
for platform in PlatformInfo.all_running_platforms.values():
|
|
platform.finalize_setup()
|
|
for pltName in PlatformInfo.all_running_platforms:
|
|
plt = PlatformInfo.all_platforms[pltName]
|
|
for tlcName in plt.toolchain_names:
|
|
tlc = Dependency.all_deps[tlcName]
|
|
builderDef = (pltName, tlcName)
|
|
builder = get_target_step(builderDef)
|
|
print("build {} ({}):".format(builder.name, pltName[0]))
|
|
add_target_step(builderDef, builder)
|
|
builder.build()
|
|
print("[GENERATE FLATPAK MANIFEST]")
|
|
self.configure()
|
|
self.copy_patches()
|
|
print("[BUILD FLATBACK]")
|
|
self.build()
|
|
print("[BUNDLE]")
|
|
self.bundle()
|
|
# No error, clean intermediate file at end of build if needed.
|
|
print("[CLEAN]")
|
|
if option('clean_at_end'):
|
|
for platform in PlatformInfo.all_running_platforms.values():
|
|
platform.clean_intermediate_directories()
|
|
else:
|
|
print("SKIP")
|
|
except StopBuild:
|
|
sys.exit("Stopping build due to errors")
|
|
|