#!/usr/bin/env python3 import urllib.request import loaih.versions as versions from lxml import etree import tempfile, os, sys, glob, subprocess, shutil class Build(object): LANGSTD = [ 'ar', 'de', 'en-GB', 'es', 'fr', 'it', 'ja', 'ko', 'pt', 'pt-BR', 'ru', 'zh-CN', 'zh-TW' ] LANGBASIC = [ 'en-GB' ] def __init__(self, query, arch): """Build all versions that can be found in the indicated repo.""" self.query = query self.arch = arch self.url = '' self.language = 'basic' self.offline_help = False self.portable = False self.updatable = True self.storage_path = '/srv/http/appimage.sys42.eu' self.download_path = '/var/tmp/downloads' self.appimagefilename = {} # Getting versions and so on v = versions.BuildVersion(self.query) # Building expected AppImageName languagepart = "." if ',' in self.language: languagepart += self.language.replace(',', '-') self.appimagefilename['x86'] = 'LibreOffice' if not self.query == 'daily' else 'LibreOfficeDev' + '-' + v.version + languagepart + '.help' if self.offline_help else '' + '-x86.AppImage' self.appimagefilename['x86_64'] = 'LibreOffice' if not self.query == 'daily' else 'LibreOfficeDev' + '-' + v.version + languagepart + '.help' if self.offline_help else '' + '-x86_64.AppImage' # Creating a tempfile self.builddir = tempfile.mkdtemp() self.tarballs = [] self.appname = 'LibreOffice' if not self.query == 'daily' else 'LibreOfficeDev' self.version = v.version self.url = v.basedirurl self.built = False def check(self, storage_path): """Checking if the requested AppImage has been already built.""" self.storage_path = storage_path + ('/portable' if self.portable else '') for arch in self.arch: res = subprocess.check_output("find {path} -name '{appimage}'".format( path = self.storage_path, appimage = self.appimagefilename[arch] + ('.zsync' if self.updatable else '') ), shell=True).decode('utf-8').strip('\n') if len(res) > 1: self.built = True if self.built: print("The requested AppImage already exists on storage. I'll skip downloading, building and moving the results.") def download(self, download_path): """Downloads the contents of the URL as it was a folder.""" if self.built: return # Let's start with defining which files are to be downloaded. # Let's explore the remote folder. self.download_path = download_path for a in self.arch: contents = etree.HTML(urllib.request.urlopen(self.url[a]).read()).xpath("//td/a") self.tarballs = [ x.text for x in contents if x.text.endswith('tar.gz') ] maintarball = self.tarballs[0] mainarr = maintarball.split('') self.appname = mainarr[0] self.version = mainarr[1] os.makedirs(self.downloaddir, existok = True) os.chdir(self.downloaddir) for archive in self.tarballs: # If the archive is already there, do not do anything. if os.path.exists(os.path.join(self.downloaddir, archive)): print("Archive %s is already there! Sweet" % archive) continue # Download the archive try: urllib.request.urlretrieve(self.url + archive, archive) except: print("Failed to download {archive}.".format(archive = archive)) print("Got %s." % archive) def build(self): """Building all the versions.""" if self.built: return # We have 4 builds to do: # * standard languages, no help # * standard languages + offline help # * all languages, no help # * all languages + offline help if self.portable and not 'portable' in self.storage_path: self.storage_path += "/portable" # Incompatibilities - if portable and updatable are asked together, # only portable will be built. if self.portable and self.updatable: print("Upgradable and portable options were required together. Building only portable.") self.updatable = False for arch in self.arch: # Preparation tasks self.appnamedir = os.path.join(self.builddir, self.appname) self.appimagedir = os.path.join(self.builddir, self.appname, self.appname + '.AppDir') os.makedirs(self.appimagedir, exist_ok = True) # And then cd to the appname folder. os.chdir(self.appnamedir) # Download appimagetool from github appimagetoolurl = "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-{arch}.AppImage".format(arch = arch) urllib.request.urlretrieve(appimagetoolurl, 'appimagetool') os.chmod('appimagetool', 0o755) # Build the requested version. self.__unpackbuild__() def __unpackbuild__(self): # We start by filtering out tarballs from the list buildtarballs = [ self.__tarballs__[0] ] # Let's process standard languages and append results to the # buildtarball if self.language == 'basic': buildtarballs.extend([ x for x in self.tarballs if 'langpack_en-GB' in x]) if self.offline_help: buildtarballs.extend([ x for x in self.tarballs if 'helppack_en-GB' in x ]) if self.language == 'standard': for lang in Build.LANGSTD: buildtarballs.extend([ x for x in self.tarballs if ('langpack' + lang) in x ]) if self.offlinehelp: buildtarballs.extend([ x for x in self.tarballs if ('helppack' + lang) in x ]) else: # In any other cases, we build with all languages if not self.offlinehelp: buildtarballs.extend([ x for x in self.tarballs if 'langpack' in x ]) else: # We need also all help. Let's replace buildtarball with the # whole bunch buildtarballs = self.tarballs # Unpacking the tarballs for archive in buildtarballs: subprocess.run("tar xzf {folder}/{archive}".format(folder = self.download_path, archive = archive), shell=True) os.chdir(self.appnamedir) os.makedirs(self.appimagedir, exist_ok = True) # At this point, let's decompress the deb packages subprocess.run("find .. -iname '*.deb' -exec dpkg -x {} . \;", shell=True, cwd=self.appimagedir) # Changing desktop file subprocess.run("find . -iname startcenter.desktop -exec cp {} . \;", shell=True, cwd=self.appimagedir) appname = 'LibreOffice' if not self.__query__ == 'daily' else 'LibreOfficeDev' subprocess.run("sed -i -e 's:^Name=.*$:Name=%s:' startcenter.desktop" % appname, shell=True, cwd=self.appimagedir) subprocess.run("find . -name '*startcenter.png' -path '*hicolor*48x48*' -exec cp {} . \;", shell=True, cwd=self.appimagedir) # Find the name of the binary called in the desktop file. binaryname = subprocess.check_output("awk 'BEGIN { FS = \"=\" } /^Exec/ { print $2; exit }' startcenter.desktop | awk '{ print $1 }'", shell=True, cwd=self.appimagedir).decode('utf-8').strip('\n') bindir=os.path.join(self.appimagedir, 'usr', 'bin') os.makedirs(bindir, exist_ok = True) subprocess.run("find ../../opt -iname soffice -path '*program*' -exec ln -sf {} ./%s \;" % binaryname, shell=True, cwd=bindir) # Download AppRun from github apprunurl = "https://github.com/AppImage/AppImageKit/releases/download/continuous/AppRun-{arch}".format(arch = arch) dest = os.path.join(self.appimagedir, 'AppRun') urllib.request.urlretrieve(apprunurl, dest) os.chmod(dest, 0o755) # Setting app version appversion = self.version + '.' + self.language if not ',' in self.language else self.language.replace(',', '-') if self.offline_help: appversion += '.help' # Building app if self.updatable: zsync = self.appimagefilename[arch] + '.zsync' subprocess.run("VERSION={version} ./appimagetool -u 'zsync|{zsync}' -v ./{appname}.AppDir/".format(version = appversion, zsync = self.appimagefilename[arch] + '.zsync', appname = self.appname), shell=True) else: subprocess.run("VERSION={version} ./appimagetool -v ./{appname}.AppDir/".format(version = appversion, appname = self.appname), shell=True) print("Built AppImage version {version}".format(version = appversion)) # Cleanup phase, before new run. for deb in glob.glob(self.appnamedir + '/*.deb'): os.remove(deb) subprocess.run("find . -type d -maxdepth 1 -exec rm -rf {} \+", shell=True) def checksums(self): """Create checksums of the built versions.""" if self.built: return os.chdir(self.appnamedir) for appimage in glob.glob('*.AppImage*'): # See if a checksum already exist if not os.path.exists(appimage + '.md5'): subprocess.run("md5sum {appimage} > {appimage}.md5".format(appimage = appimage), shell=True) def move(self): """Moves built versions to definitive storage.""" if self.built: return os.chdir(self.appnamedir) subprocess.run("find . -iname '*.AppImage*' -exec cp {} %s \;" % self.storage_path, shell=True) def __del__(self): """Destructor""" # Cleaning up build directory shutil.rmtree(self.builddir)