238 lines
12 KiB
Python
238 lines
12 KiB
Python
import os
|
|
import sys
|
|
import sysconfig
|
|
import copy
|
|
import collections
|
|
from typing import Any, Dict, List, MutableMapping, Optional
|
|
from components import CommonUtils
|
|
|
|
# Module which handles everything to do with environment variables in relation to builds
|
|
|
|
# Method which determines the appropriate environment variables to set for builds
|
|
# This ensures that build systems and running tests can find the dependencies located within it
|
|
def generateFor( installPrefix: str, configuration : Optional[Dict[str, Any]] = None) -> MutableMapping[str, str]:
|
|
# Create our initial store for environment changes
|
|
envChanges: Dict[str, List[str]] = collections.defaultdict(list)
|
|
|
|
# We always check the install prefix we've been given - so let's look there first
|
|
envChanges = changesForPrefix( os.path.realpath( installPrefix ), envChanges )
|
|
|
|
# Are we on Windows?
|
|
if sys.platform == 'win32' and 'CRAFT_ROOT' in os.environ:
|
|
# Then we need to consider Craft...
|
|
# Grab our Craft Root directory
|
|
craftRoot = os.path.realpath(os.environ['CRAFT_ROOT'])
|
|
# Process the base directory first
|
|
envChanges = changesForPrefix( craftRoot, envChanges )
|
|
# As well as it's dev-utils directory (why it's split up like this - no clue...)
|
|
utilsPrefix = os.path.join( craftRoot, 'dev-utils' )
|
|
envChanges = changesForPrefix( utilsPrefix, envChanges )
|
|
|
|
# Are we performing an Android build?
|
|
if 'ANDROID_HOME' in os.environ and sys.platform == 'linux':
|
|
# Then we need to include the separate Qt SDK for Android
|
|
# Grab it's directory
|
|
envChanges = changesForPrefix( '/opt/Qt', envChanges )
|
|
# We also need to include other dependencies which are shipped in the Docker SDK image
|
|
envChanges = changesForPrefix( '/opt/kdeandroid-arm', envChanges )
|
|
envChanges = changesForPrefix( '/opt/kdeandroid-arm64', envChanges )
|
|
envChanges = changesForPrefix( '/home/user/android-arm-clang', envChanges )
|
|
envChanges = changesForPrefix( '/home/user/android-arm64-clang', envChanges )
|
|
|
|
# Otherwise are we on a Non-Windows / Mac platform?
|
|
elif sys.platform != 'win32' and sys.platform != 'darwin':
|
|
# Use wayland-protocols that we built from source code
|
|
envChanges = changesForPrefix( '/opt/wayland-protocols', envChanges )
|
|
# The we need to consider the system install prefix
|
|
# Normally these would be setup for us, but this is just to be absolutely sure everything is right
|
|
envChanges = changesForPrefix( "/usr/", envChanges, systemPrefix=True )
|
|
# We should also consider /usr/local/ as FreeBSD uses this as a system prefix quite extensively
|
|
envChanges = changesForPrefix( "/usr/local/", envChanges, systemPrefix=True )
|
|
|
|
# On FreeBSD LLVM gets installed to it's own separate prefix
|
|
# Make sure that is included too
|
|
if sys.platform == 'freebsd12' or sys.platform == 'freebsd13' or sys.platform == 'freebsd14' or sys.platform == 'freebsd15':
|
|
# Include the necessary LLVM path then
|
|
envChanges = changesForPrefix( "/usr/local/llvm21", envChanges )
|
|
|
|
# Now we can merge this into the real environment
|
|
splitChar = separatorCharacter()
|
|
# NOTE: convert `os.environ` to a dict before deep-copying, otherwise changes to the environment will leak to the host process
|
|
clonedEnv = copy.deepcopy( dict(os.environ) )
|
|
for variableName, variableEntries in envChanges.items():
|
|
# Join them
|
|
newEntry = splitChar.join( variableEntries )
|
|
# If the variable already exists in the system environment, we prefix ourselves on
|
|
if variableName in clonedEnv:
|
|
newEntry = '%s%s%s' % (newEntry, splitChar, clonedEnv[variableName])
|
|
# Set the variable into our cloned environment
|
|
clonedEnv[variableName] = newEntry
|
|
|
|
# If we're on Windows or MacOS, then setting XDG_DATA_DIRS will have no effect whatsoever
|
|
# Fortunately, even though Qt Upstream doesn't support this, the Craft patched version of Qt does support the QT_DATA_DIRS variable which will be followed
|
|
# To ensure all our resources can be found, we make sure QT_DATA_DIRS is set
|
|
# We leave XDG_DATA_DIRS set to ensure any tools which haven't been adapted to the Windows/Mac environment continue to work
|
|
if sys.platform == 'win32' or sys.platform == 'darwin':
|
|
clonedEnv['QT_DATA_DIRS'] = clonedEnv['XDG_DATA_DIRS']
|
|
|
|
# Qt needs hand holding in order to work properly
|
|
# We only do this if we are in a Qt 5 environment which we determine by the absence of a Qt 4 environment
|
|
if sys.platform != 'win32' and not os.path.exists('/usr/bin/qmake-qt4'):
|
|
clonedEnv['QT_SELECT'] = 'qt5'
|
|
|
|
# QtWebEngine on Windows needs additional handholding on top of the above
|
|
if sys.platform == 'win32' and 'CRAFT_ROOT' in os.environ:
|
|
# Determine where the resources folder should be found...
|
|
resourceFileLocation = os.path.join( os.environ['CRAFT_ROOT'], 'bin', 'qtwebengine_resources.pak' )
|
|
# Then make sure it exists
|
|
if os.path.exists( resourceFileLocation ):
|
|
clonedEnv['QTWEBENGINE_RESOURCES_PATH'] = os.path.join( os.environ['CRAFT_ROOT'], 'bin' )
|
|
|
|
# If this is a Linux/FreeBSD system, making sure we're going to have a UTF-8 environment
|
|
if sys.platform == 'linux' or sys.platform == 'freebsd12' or sys.platform == 'freebsd13' or sys.platform == 'freebsd14' or sys.platform == 'freebsd15':
|
|
clonedEnv['LANG'] = 'en_US.UTF-8'
|
|
|
|
# Mark ourselves as a KDE session, for things like the platform plugin, etc.
|
|
clonedEnv['XDG_CURRENT_DESKTOP'] = 'KDE'
|
|
# Ensure Git security measures don't break the likes of Git LFS / Git Annex
|
|
clonedEnv['GIT_CLONE_PROTECTION_ACTIVE'] = 'false'
|
|
|
|
# Ensure that ASAN is not disruptive
|
|
asan_options = ["new_delete_type_mismatch=0", "detect_odr_violation=0", "stack-use-after-scope=0", "alloc_dealloc_mismatch=0", "verify_asan_link_order=0"]
|
|
lsan_options = []
|
|
|
|
# Ensure LSAN is disabled if we do not have it enabled
|
|
if configuration and not configuration['Options']['enable-lsan']:
|
|
asan_options.append("detect_leaks=0")
|
|
|
|
# If LSAN is enabled then ensure we get the best results from it
|
|
if configuration and configuration['Options']['enable-lsan']:
|
|
asan_options.append("fast_unwind_on_malloc=0")
|
|
suppressionDefinitions = os.path.join(CommonUtils.scriptsBaseDirectory(), 'resources', 'lsan.supp')
|
|
lsan_options.append("suppressions=" + suppressionDefinitions)
|
|
|
|
# On FreeBSD we also want ASAN to be symbolised to aid in debugging
|
|
# Additionally, we disable container overflow detection, as this seems to have generated false positives on FreeBSD
|
|
if sys.platform == 'freebsd12' or sys.platform == 'freebsd13' or sys.platform == 'freebsd14' or sys.platform == 'freebsd15':
|
|
asan_options.append("detect_container_overflow=0")
|
|
asan_options.append("symbolize=1")
|
|
|
|
# Apply the ASAN configuration
|
|
clonedEnv['ASAN_OPTIONS'] = ":".join(asan_options)
|
|
|
|
# Apply the LSAN configuration
|
|
clonedEnv['LSAN_OPTIONS'] = ":".join(lsan_options)
|
|
|
|
# All done
|
|
return clonedEnv
|
|
|
|
def changesForPrefix( installPrefix: str, envChanges: Dict[str, List[str]], systemPrefix: bool=False ) -> Dict[str, List[str]]:
|
|
# Setup CMAKE_PREFIX_PATH
|
|
extraLocation = os.path.join( installPrefix )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['CMAKE_PREFIX_PATH'].append( extraLocation )
|
|
|
|
# Setup PATH
|
|
extraLocation = os.path.join( installPrefix, 'bin' )
|
|
if os.path.exists( extraLocation ) and not systemPrefix:
|
|
envChanges['PATH'].append(extraLocation)
|
|
|
|
# Handle those paths which involve $prefix/lib*
|
|
libDirSuffixes = ['lib', 'lib32', 'lib64', 'lib/x86_64-linux-gnu', 'libdata']
|
|
if sys.platform == 'win32':
|
|
libDirSuffixes.append('lib/qt6')
|
|
for libraryDirName in libDirSuffixes:
|
|
# Do LD_LIBRARY_PATH
|
|
extraLocation = os.path.join( installPrefix, libraryDirName )
|
|
if os.path.exists( extraLocation ) and not systemPrefix:
|
|
envChanges[ libraryPathVariableName() ].append(extraLocation)
|
|
|
|
# Now do PKG_CONFIG_PATH
|
|
extraLocation = os.path.join( installPrefix, libraryDirName, 'pkgconfig' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['PKG_CONFIG_PATH'].append(extraLocation)
|
|
|
|
# Next up is QT_PLUGIN_PATH
|
|
for pluginDirName in ['plugins', 'qca-qt5']:
|
|
extraLocation = os.path.join( installPrefix, libraryDirName, pluginDirName )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['QT_PLUGIN_PATH'].append(extraLocation)
|
|
|
|
# Now we do QML2_IMPORT_PATH
|
|
extraLocation = os.path.join( installPrefix, libraryDirName, 'qml' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['QML2_IMPORT_PATH'].append(extraLocation)
|
|
|
|
# For Python bindings
|
|
extraLocation = sysconfig.get_path('platlib', vars={'platbase': installPrefix, 'base': installPrefix, 'platlibdir': libraryDirName})
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['PYTHONPATH'].append(extraLocation)
|
|
|
|
# .pc files are installed in $prefix/share/pkgconfig as well
|
|
extraLocation = os.path.join( installPrefix, 'share', 'pkgconfig' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['PKG_CONFIG_PATH'].append(extraLocation)
|
|
|
|
# Special Case for QT_PLUGIN_PATH and QML2_IMPORT_PATH
|
|
# On Windows these are installed to $prefix/bin/$pluginDirName rather than under $prefix/lib/$pluginDirName
|
|
if sys.platform == 'win32':
|
|
# Check QT_PLUGIN_PATH first
|
|
for pluginDirName in ['plugins', 'qca-qt5']:
|
|
extraLocation = os.path.join( installPrefix, 'bin', pluginDirName )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['QT_PLUGIN_PATH'].append(extraLocation)
|
|
|
|
# Now we do QML2_IMPORT_PATH
|
|
extraLocation = os.path.join( installPrefix, 'bin', 'qml' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['QML2_IMPORT_PATH'].append(extraLocation)
|
|
|
|
# Setup XDG_DATA_DIRS - used to ensure applications on XDG platforms find their resources
|
|
if sys.platform == 'win32':
|
|
# On Windows KDE_INSTALL_DATADIR and KDE_INSTALL_DATAROOTDIR will install to "bin/data" instead of "share"
|
|
# See https://api.kde.org/ecm/kde-module/KDEInstallDirs6.html
|
|
extraLocation = os.path.join( installPrefix, 'bin', 'data' )
|
|
else:
|
|
extraLocation = os.path.join( installPrefix, 'share' )
|
|
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['XDG_DATA_DIRS'].append(extraLocation)
|
|
|
|
# Setup XDG_CONFIG_DIRS - needed to ensure XDG based applications find their configuration
|
|
extraLocation = os.path.join( installPrefix, 'etc/xdg' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['XDG_CONFIG_DIRS'].append(extraLocation)
|
|
|
|
# Setup QMAKEFEATURES
|
|
# This mostly undocumented environment variable lets QMake find *.pri files which are outside Qt's install prefix
|
|
extraLocation = os.path.join( installPrefix, 'mkspecs/features' )
|
|
if os.path.exists( extraLocation ):
|
|
envChanges['QMAKEFEATURES'].append( extraLocation )
|
|
|
|
return envChanges
|
|
|
|
# Which character should be used as a separator for paths?
|
|
def separatorCharacter() -> str:
|
|
# Are we on Windows?
|
|
if sys.platform == 'win32':
|
|
# Then semi-colon it is
|
|
return ';'
|
|
|
|
# Everything else uses a full colon
|
|
return ':'
|
|
|
|
# Which environment variable is used to influence the loading of libraries?
|
|
def libraryPathVariableName() -> str:
|
|
# Are we on OS X?
|
|
if sys.platform == 'darwin':
|
|
# OS X with System Integrity Protection does not support this at all - it will be unset when calling any system binary (incl. shell interpreters)
|
|
# The variable is DYLD_LIBRARY_PATH, but considering it will only be passed through sometimes, we may as well not bother with setting it
|
|
return 'IGNORE_THIS_VARIABLE'
|
|
|
|
# Are we on Windows?
|
|
if sys.platform == 'win32':
|
|
# Windows uses PATH for this - interesting choice Microsoft...
|
|
return 'PATH'
|
|
|
|
# Everything else (Linux, FreeBSD, etc) uses LD_LIBRARY_PATH for this
|
|
return 'LD_LIBRARY_PATH'
|