def getDependencies(category, package, runtimeOnly=False):
"""returns the dependencies of this package as list of strings:
category/package"""
subpackage, package = getSubPackage(category, package)
if subpackage:
EmergeDebug.debug(
"solving package %s/%s/%s %s" %
(category, subpackage, package, getFilename(category, package)))
else:
EmergeDebug.debug("solving package %s/%s %s" %
(category, package, getFilename(category, package)))
deps = []
info = _getSubinfo(category, package)
if not info is None:
depDict = info.dependencies
depDict.update(info.runtimeDependencies)
if not runtimeOnly:
depDict.update(info.buildDependencies)
for line in depDict:
(category, package) = line.split("/")
version = PortageInstance.getNewestVersion(category, package)
deps.append([category, package, version, depDict[line]])
return deps
def cleanBuild( self ):
"""cleanup currently used build dir"""
if os.path.exists( self.buildDir() ):
utils.cleanDirectory( self.buildDir() )
EmergeDebug.debug("cleaning build dir: %s" % self.buildDir(), 1)
return True
def getHttpFile( host, path, destdir, filename ):
"""download file from a http host specified by 'host' and 'path' into 'destdir' using 'filename' as file name"""
# FIXME check return values here (implement useful error handling)...
EmergeDebug.debug("getHttpFile called. %s %s" % (host, path), 1)
conn = http.client.HTTPConnection( host )
conn.request( "GET", path )
r1 = conn.getresponse()
EmergeDebug.debug("status: %s; reason: %s" % (str(r1.status), str(r1.reason)))
count = 0
while r1.status == 302:
if count > 10:
EmergeDebug.debug("Redirect loop")
return False
count += 1
_, host, path, _, _, _ = urllib.parse.urlparse( r1.getheader( "Location" ) )
EmergeDebug.debug("Redirection: %s %s" % (host, path), 1)
conn = http.client.HTTPConnection( host )
conn.request( "GET", path )
r1 = conn.getresponse()
EmergeDebug.debug("status: %s; reason: %s" % (str(r1.status), str(r1.reason)))
data = r1.read()
with open( os.path.join( destdir, filename ), "wb" ) as f:
f.write( data )
return True
def compile(self):
if not ("Paths", "Python27") in emergeSettings:
EmergeDebug.die(
"Please make sure Paths/Python27 is set in your kdesettings.ini"
)
utils.prependPath(emergeSettings.get("Paths", "PYTHON27", ""))
return Qt5CorePackageBase.compile(self)
def buildDir(self):
EmergeDebug.debug("EmergeBase.buildDir() called", 2)
builddir = os.path.join(self.workDir(), self.workDirPattern())
if self.subinfo.options.unpack.unpackIntoBuildDir and self.subinfo.hasTargetSourcePath():
builddir = os.path.join(builddir, self.subinfo.targetSourcePath())
EmergeDebug.debug("package builddir is: %s" % builddir, 2)
return self.__adjustPath(builddir)
def _defaulVersions( self ):
if self.__defaulVersions is None:
name = self.subinfo.parent.filename
if name in VersionInfo._VERSION_INFOS_HINTS:
if VersionInfo._VERSION_INFOS_HINTS[ name ] == None:
return None
else:
#utils.debug("Using cached version info for %s in %s" % (name, _VERSION_INFOS_HINTS[ name ]))
return VersionInfo._VERSION_INFOS[ VersionInfo._VERSION_INFOS_HINTS[ name ] ]
root = os.path.dirname( name )
if self._fileName is None:
possibleInis= [ os.path.join( root, "version.ini" ), os.path.join( root, "..", "version.ini" ),
os.path.join( root, "..", "..", "version.ini" ) ]
else:
possibleInis = [self._fileName]
for iniPath in possibleInis:
iniPath = os.path.abspath( iniPath )
if iniPath in VersionInfo._VERSION_INFOS.keys( ):
VersionInfo._VERSION_INFOS_HINTS[ name ] = iniPath
EmergeDebug.debug("Found a version info for %s in cache" % name, 2)
return VersionInfo._VERSION_INFOS[ iniPath ]
elif os.path.exists( iniPath ):
config = configparser.ConfigParser( )
config.read( iniPath )
VersionInfo._VERSION_INFOS[ iniPath ] = config
VersionInfo._VERSION_INFOS_HINTS[ name ] = iniPath
EmergeDebug.debug("Found a version info for %s in %s" % (name, iniPath), 2)
return config
VersionInfo._VERSION_INFOS_HINTS[ name ] = None
return self.__defaulVersions
def __init__(self):
EmergeDebug.debug("SetupPackageBase.__init__ called", 2)
PackageBase.__init__(self)
MultiSource.__init__(self)
BuildSystemBase.__init__(self)
PackagerBase.__init__(self)
self.subinfo.options.unpack.runInstaller = True
def getDependencies( category, package, runtimeOnly = False ):
"""returns the dependencies of this package as list of strings:
category/package"""
subpackage, package = getSubPackage( category, package )
if subpackage:
EmergeDebug.debug("solving package %s/%s/%s %s" % (category, subpackage, package,
getFilename( category, package )))
else:
EmergeDebug.debug("solving package %s/%s %s" % (category, package, getFilename(category, package)))
subpackage = package
deps = []
for pkg in [ subpackage ]:
info = _getSubinfo(category, pkg)
if not info is None:
depDict = info.dependencies
depDict.update( info.runtimeDependencies )
if not runtimeOnly:
depDict.update( info.buildDependencies )
for line in list(depDict.keys()):
(category, package) = line.split( "/" )
version = PortageInstance.getNewestVersion( category, package )
deps.append( [ category, package, version, depDict[ line ] ] )
return deps
def getPackagesCategories(packageName, defaultCategory = None):
EmergeDebug.trace("getPackagesCategories for package name %s" % packageName)
if defaultCategory is None:
defaultCategory = emergeSettings.get("General","EMERGE_DEFAULTCATEGORY","kde")
packageList, categoryList = [], []
if len( packageName.split( "/" ) ) == 1:
if PortageInstance.isCategory( packageName ):
EmergeDebug.debug("isCategory=True", 2)
packageList = PortageInstance.getAllPackages( packageName )
categoryList = [ packageName ] * len(packageList)
else:
EmergeDebug.debug("isCategory=False", 2)
if PortageInstance.isCategory( defaultCategory ) and PortageInstance.isPackage( defaultCategory, packageName ):
# prefer the default category
packageList = [ packageName ]
categoryList = [ defaultCategory ]
else:
if PortageInstance.getCategory( packageName ):
packageList = [ packageName ]
categoryList = [ PortageInstance.getCategory( packageName ) ]
elif len( packageName.split( "/" ) ) == 2:
[ cat, pac ] = packageName.split( "/" )
if PortageInstance.isCategory( cat ):
categoryList = [ cat ]
else:
return packageList, categoryList
if len( categoryList ) > 0 and PortageInstance.isPackage( categoryList[0], pac ):
packageList = [ pac ]
if len( categoryList ) and len( packageList ):
EmergeDebug.debug("added package %s/%s" % (categoryList[0], pac), 2)
else:
EmergeDebug.error("unknown packageName")
return packageList, categoryList
def unpack(self):
EmergeDebug.trace("MultiSource unpack", 2)
# pylint: disable=E1101
# multiple inheritance: MultiSource is never the only
# superclass, others define self.buildSystemType.
self.source.buildSystemType = self.buildSystemType
return self.source.unpack()
def getPackageInstance(self, category, package):
"""return instance of class Package from package file"""
fileName = getFilename( category, package )
pack = None
mod = None
if fileName.endswith(".py") and os.path.isfile(fileName):
if not fileName in self._packageDict:
EmergeDebug.debug("module to import: %s" % fileName, 2)
if not os.path.isfile( fileName ):
try:
mod = builtins.__import__( fileName )
except ImportError as e:
EmergeDebug.warning('import failed for module %s: %s' % (fileName, str(e)))
mod = None
else:
modulename = os.path.basename( fileName )[:-3].replace('.', '_')
loader = importlib.machinery.SourceFileLoader(modulename, fileName)
try:
mod = loader.load_module()
except Exception as e:
raise PortageException("Failed to load file %s" % fileName, category, package, e)
if not mod is None:
subpackage, package = getSubPackage( category, package )
self._CURRENT_MODULE = ( fileName, category,subpackage, package, mod )
pack = mod.Package( )
self._packageDict[ fileName ] = pack
else:
raise PortageException("Failed to find package", category, package)
else:
pack = self._packageDict[ fileName ]
return pack
def fetch( self, repopath=None ):
"""try to clone or update the repository"""
EmergeDebug.trace("HgSource.fetch called", 2)
# get the path where the repositories should be stored to
if repopath == None:
repopath = self.repositoryUrl()
# in case you need to move from a read only Url to a writeable one, here it gets replaced
# repoString = utils.replaceVCSUrl( repopath )
repopath = repopath.replace("[hg]", "")
repoUrl, repoBranch, _ = utils.splitVCSUrl( repopath )
ret = True
# only run if wanted (e.g. no --offline is given on the commandline) or no hg support is given by the python installation
if ( not self.noFetch and self.enableHg ):
# question whether mercurial stuff uses these proxies
self.setProxy()
checkoutDir = self.checkoutDir()
# check corrupted checkout dir
if os.path.exists( checkoutDir ) and not os.path.exists( checkoutDir + "\.hg" ):
os.rmdir( checkoutDir )
if not os.path.exists( checkoutDir ):
os.makedirs( checkoutDir )
os.chdir( checkoutDir )
ret = self.system( "%s clone %s ." % ( self.hgExecutable, repoUrl ) ) # TODO: check return code for success
if os.path.exists( checkoutDir ):
os.chdir( checkoutDir )
ret = self.system( "%s update %s" % ( self.hgExecutable, repoBranch ) ) # TODO: check return code for success
else:
EmergeDebug.debug("skipping hg fetch (--offline)")
return ret
def fetch( self, dummyRepopath = None ):
"""fetch normal tarballs"""
EmergeDebug.debug("ArchiveSource.fetch called", 2)
filenames = self.localFileNames()
if ( self.noFetch ):
EmergeDebug.debug("skipping fetch (--offline)")
return True
self.setProxy()
if self.subinfo.hasTarget():
if self.__checkFilesPresent(filenames):
EmergeDebug.debug("files and digests available, no need to download files", 1)
return True
result = utils.getFiles( self.subinfo.target(), EmergeStandardDirs.downloadDir() , filenames = self.subinfo.archiveName() )
if not result:
EmergeDebug.debug("failed to download files", 1)
return False
if result and self.subinfo.hasTargetDigestUrls():
if type(self.subinfo.targetDigestUrl()) == tuple:
url, alg = self.subinfo.targetDigestUrl()
return utils.getFiles(url, EmergeStandardDirs.downloadDir(),
filenames = self.subinfo.archiveName()[0]
+ EmergeHash.HashAlgorithm.fileEndings().get(alg))
else:
return utils.getFiles( self.subinfo.targetDigestUrl(), EmergeStandardDirs.downloadDir(), filenames = '' )
else:
EmergeDebug.debug("no digestUrls present", 2)
return True
else:
return utils.getFiles( "", EmergeStandardDirs.downloadDir() )
def unpack(self):
"""unpacking all zipped(gz, zip, bz2) tarballs"""
EmergeDebug.debug("ArchiveSource.unpack called", 2)
filenames = self.localFileNames()
# TODO: this might delete generated patches
utils.cleanDirectory(self.workDir())
if not self.checkDigest():
return False
binEndings = (".exe", ".bat", ".msi")
for filename in filenames:
if filename.endswith(binEndings):
filePath = os.path.abspath( os.path.join(EmergeStandardDirs.downloadDir(), filename) )
if self.subinfo.options.unpack.runInstaller:
_, ext = os.path.splitext( filename )
if ext == ".exe":
return utils.system("%s" % filePath )
elif ( ext == ".msi" ):
return utils.system("msiexec /package %s" % filePath )
if not utils.copyFile( filePath, os.path.join(self.workDir(), filename) ):
return False
else:
if not utils.unpackFile( EmergeStandardDirs.downloadDir(), filename, self.workDir()):
return False
ret = self.applyPatches()
if emergeSettings.getboolean("General","EMERGE_HOLD_ON_PATCH_FAIL",False):
return ret
return True
def getFile( url, destdir , filename='' ):
"""download file from 'url' into 'destdir'"""
EmergeDebug.debug("getFile called. url: %s" % url, 1)
if url == "":
EmergeDebug.error("fetch: no url given")
return False
if UtilsCache.findApplication("wget"):
return wgetFile( url, destdir , filename )
if not filename:
_, _, path, _, _, _ = urllib.parse.urlparse( url )
filename = os.path.basename( path )
if os.path.exists(os.path.join( destdir, filename )):
return True
width, _ = shutil.get_terminal_size((80,20))
def dlProgress(count, blockSize, totalSize):
percent = int(count * blockSize * 100 / totalSize)
times = int((width - 20)/100 * percent)
sys.stdout.write(("\r%s%3d%%" % ("#" * times, percent)))
sys.stdout.flush()
urllib.request.urlretrieve(url, filename = os.path.join( destdir, filename ), reporthook= dlProgress if EmergeDebug.verbose() >= 0 else None )
if EmergeDebug.verbose()>=0:
sys.stdout.write("\n")
sys.stdout.flush()
return True
def make( self ):
"""implements the make step for cmake projects"""
self.enterBuildDir()
utils.prependPath(self.rootdir, self.envPath)
if self.subinfo.options.cmake.openIDE:
if compiler.isMSVC2008():
command = "start %s" % self.__slnFileName()
elif compiler.isMSVC2010():
command = "start vcexpress %s" % self.__slnFileName()
elif self.subinfo.options.cmake.useIDE:
if compiler.isMSVC2008():
command = "vcbuild /M1 %s \"%s|WIN32\"" % (self.__slnFileName(), self.buildType())
elif compiler.isMSVC2015():
command = "msbuild /maxcpucount %s /t:ALL_BUILD /p:Configuration=\"%s\"" % (self.__slnFileName(), self.buildType())
elif compiler.isMSVC2010():
EmergeDebug.die("has to be implemented");
elif self.subinfo.options.cmake.useCTest:
# first make clean
self.system( self.makeProgramm + " clean", "make clean" )
command = "ctest -M " + "Nightly" + " -T Start -T Update -T Configure -T Build -T Submit"
else:
command = ' '.join([self.makeProgramm, self.makeOptions()])
return self.system( command, "make" )
def cleanBuild( self ) -> bool:
"""cleanup currently used build dir"""
if os.path.exists( self.buildDir() ):
utils.cleanDirectory( self.buildDir() )
EmergeDebug.debug("cleaning build dir: %s" % self.buildDir(), 1)
return True
def __makeFileGenerator(self):
"""return cmake related make file generator"""
if self.supportsNinja and emergeSettings.getboolean("Compile","UseNinja", False):
return "Ninja"
if compiler.isMSVC2015():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 14 2015" + " Win64" if compiler.isX64() else ""
else:
return "NMake Makefiles"
if compiler.isMSVC2010():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 10"
else:
return "NMake Makefiles"
elif compiler.isMSVC2008():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 9 2008"
else:
return "NMake Makefiles"
elif compiler.isMSVC() or compiler.isIntel():
return "NMake Makefiles"
elif compiler.isMinGW():
return "MinGW Makefiles"
else:
EmergeDebug.die("unknown %s compiler" % self.compiler())
def PackagerFactory(parent, packagerType):
"""provides multi packager type api
return PackagerBase derived instance for recent settings"""
EmergeDebug.debug("PackagerFactory called", 2)
packagers = []
if packagerType:
for packagerClass in packagerType:
if not issubclass(packagerClass, PackagerBase):
EmergeDebug.die("PackagerFactory: unsupported packager %s" % packagerClass)
else:
packager = packagerClass()
init(packager, parent)
packagers.append(packager)
else:
# automatic detection
packager = InnoSetupPackager()
init(packager, parent)
if packager.configFile() != None:
packagers.append(packager)
# default packager
if len(packagers) == 0:
packager = KDEWinPackager()
init(packager, parent)
packagers.append(packager)
return packagers
def _fixCmakeImageDir(self, imagedir, rootdir ):
"""
when using DESTDIR=foo under windows, it does not _replace_
CMAKE_INSTALL_PREFIX with it, but prepends destdir to it.
so when we want to be able to install imagedir into KDEROOT,
we have to move things around...
"""
EmergeDebug.debug("fixImageDir: %s %s" % (imagedir, rootdir), 1)
# imagedir = e:\foo\thirdroot\tmp\dbus-0\image
# rootdir = e:\foo\thirdroot
# files are installed to
# e:\foo\thirdroot\tmp\dbus-0\image\foo\thirdroot
_, rootpath = os.path.splitdrive( rootdir )
#print "rp:", rootpath
if ( rootpath.startswith( os.path.sep ) ):
rootpath = rootpath[1:]
# CMAKE_INSTALL_PREFIX = X:\
# -> files are installed to
# x:\build\foo\dbus\image\
# --> all fine in this case
#print("rp:", rootpath)
if len(rootpath) == 0:
return
tmp = os.path.join( imagedir, rootpath )
EmergeDebug.debug("tmp: %s" % tmp, 1)
tmpdir = os.path.join( imagedir, "tMpDiR" )
if ( not os.path.isdir( tmpdir ) ):
os.mkdir( tmpdir )
utils.moveEntries( tmp, tmpdir )
os.chdir( imagedir )
os.removedirs( rootpath )
utils.moveEntries( tmpdir, imagedir )
utils.cleanDirectory( tmpdir )
os.rmdir( tmpdir )
def __getImageDirectories( self ):
""" return the image directories where the files are stored """
imageDirs = []
runtimeDependencies = portage.getDependencies(self.category, self.package)
depList = []
for ( category, package, _, _ ) in runtimeDependencies:
# we only want runtime dependencies since we want to build a binary installer
portage.solveDependencies(category, package, depList = depList,
depType = DependencyType.Runtime, ignoredPackages = self.ignoredPackages)
depList.reverse()
# make sure current package is added to the list, too
if not self.package.endswith("-package"):
depList.append(DependencyPackage(self.category, self.package))
for x in depList:
if portage.PortageInstance.isVirtualPackage(x.category, x.package):
EmergeDebug.debug("Ignoring package b/c it is virtual: %s/%s" % (x.category, x.package))
continue
_package = portage.getPackageInstance( x.category, x.package )
imageDirs.append(( os.path.join( self.rootdir, "build", x.category, x.package,
self.__imageDirPattern( _package, _package.buildTarget )), _package.subinfo.options.merge.destinationPath , _package.subinfo.options.package.disableStriping ) )
# this loop collects the files from all image directories
EmergeDebug.debug("__getImageDirectories: category: %s, package: %s, version: %s, defaultTarget: %s" % (_package.category, x.package, _package.version, _package.buildTarget), 2)
if emergeSettings.getboolean("QtSDK", "Enabled", "false"):
imageDirs.append((os.path.join( emergeSettings.get("QtSDK", "Path") , emergeSettings.get("QtSDK", "Version"), emergeSettings.get("QtSDK", "Compiler")), None, False))
return imageDirs
def make(self):
"""implements the make step for cmake projects"""
self.enterBuildDir()
utils.prependPath(self.rootdir, self.envPath)
if self.subinfo.options.cmake.openIDE:
if compiler.isMSVC2008():
command = "start %s" % self.__slnFileName()
elif compiler.isMSVC2010():
command = "start vcexpress %s" % self.__slnFileName()
elif self.subinfo.options.cmake.useIDE:
if compiler.isMSVC2008():
command = "vcbuild /M1 %s \"%s|WIN32\"" % (
self.__slnFileName(), self.buildType())
elif compiler.isMSVC2015():
command = "msbuild /maxcpucount %s /t:ALL_BUILD /p:Configuration=\"%s\"" % (
self.__slnFileName(), self.buildType())
elif compiler.isMSVC2010():
EmergeDebug.die("has to be implemented")
elif self.subinfo.options.cmake.useCTest:
# first make clean
self.system(self.makeProgramm + " clean", "make clean")
command = "ctest -M " + "Nightly" + " -T Start -T Update -T Configure -T Build -T Submit"
else:
command = ' '.join([self.makeProgramm, self.makeOptions()])
return self.system(command, "make")
def unpack(self):
EmergeDebug.trace("MultiSource unpack", 2)
# pylint: disable=E1101
# multiple inheritance: MultiSource is never the only
# superclass, others define self.buildSystemType.
self.source.buildSystemType = self.buildSystemType
return self.source.unpack()
def __makeFileGenerator(self):
"""return cmake related make file generator"""
if self.supportsNinja and emergeSettings.getboolean(
"Compile", "UseNinja", False):
return "Ninja"
if compiler.isMSVC2015():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 14 2015" + " Win64" if compiler.isX64(
) else ""
else:
return "NMake Makefiles"
if compiler.isMSVC2010():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 10"
else:
return "NMake Makefiles"
elif compiler.isMSVC2008():
if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
return "Visual Studio 9 2008"
else:
return "NMake Makefiles"
elif compiler.isMSVC() or compiler.isIntel():
return "NMake Makefiles"
elif compiler.isMinGW():
return "MinGW Makefiles"
else:
EmergeDebug.die("unknown %s compiler" % self.compiler())
def cleanImage( self ):
"""cleanup before install to imagedir"""
if ( os.path.exists( self.imageDir() ) ):
EmergeDebug.debug("cleaning image dir: %s" % self.imageDir(), 1)
utils.cleanDirectory( self.imageDir() )
os.rmdir(self.imageDir())
return True
def dumpCMakeDependencies(self):
"""dump package dependencies as pdf (requires installed dot)"""
srcDir = self.sourceDir()
outDir = self.buildDir()
self.enterBuildDir()
outFile = os.path.join(outDir, self.package + '-cmake.dot')
a = CMakeDependencies()
if not a.parse(srcDir):
EmergeDebug.debug(
"could not find source files for generating cmake dependencies"
)
return False
title = "%s cmake dependency chart - version %s" % (self.package,
self.version)
a.toPackageList(title, srcDir)
if not a.toDot(title, srcDir, outFile):
EmergeDebug.debug("could not create dot file")
return False
graphviz = GraphViz(self)
if not graphviz.runDot(outFile, outFile + '.pdf', 'pdf'):
return False
return graphviz.openOutput()
def SourceFactory(settings):
""" return sourceBase derived instance for recent settings"""
EmergeDebug.trace("SourceFactory called", 1)
source = None
if settings.hasTarget():
if settings.hasMultipleTargets():
url = settings.targetAt(0)
else:
url = settings.target()
source = ArchiveSource(settings)
## \todo move settings access into info class
if settings.hasSvnTarget():
url = settings.svnTarget()
sourceType = utils.getVCSType( url )
if sourceType == "svn":
source = SvnSource(settings)
elif sourceType == "hg":
source = HgSource(settings)
elif sourceType == "git":
source = GitSource(settings)
if source == None:
EmergeDebug.die("none or unsupported source system set")
if not source.subinfo:
source.subinfo = settings
source.url = url
return source
def _fixCmakeImageDir(self, imagedir, rootdir):
"""
when using DESTDIR=foo under windows, it does not _replace_
CMAKE_INSTALL_PREFIX with it, but prepends destdir to it.
so when we want to be able to install imagedir into KDEROOT,
we have to move things around...
"""
EmergeDebug.debug("fixImageDir: %s %s" % (imagedir, rootdir), 1)
# imagedir = e:\foo\thirdroot\tmp\dbus-0\image
# rootdir = e:\foo\thirdroot
# files are installed to
# e:\foo\thirdroot\tmp\dbus-0\image\foo\thirdroot
_, rootpath = os.path.splitdrive(rootdir)
#print "rp:", rootpath
if (rootpath.startswith(os.path.sep)):
rootpath = rootpath[1:]
# CMAKE_INSTALL_PREFIX = X:\
# -> files are installed to
# x:\build\foo\dbus\image\
# --> all fine in this case
#print("rp:", rootpath)
if len(rootpath) == 0:
return
tmp = os.path.join(imagedir, rootpath)
EmergeDebug.debug("tmp: %s" % tmp, 1)
tmpdir = os.path.join(imagedir, "tMpDiR")
if (not os.path.isdir(tmpdir)):
os.mkdir(tmpdir)
utils.moveEntries(tmp, tmpdir)
os.chdir(imagedir)
os.removedirs(rootpath)
utils.moveEntries(tmpdir, imagedir)
utils.cleanDirectory(tmpdir)
os.rmdir(tmpdir)
def renameDir(src, dest):
""" rename a directory """
EmergeDebug.debug("rename directory from %s to %s" % (src, dest), 2)
if os.rename( src, dest ) == 0:
return False
else:
return True
def cleanImage( self ) -> bool:
"""cleanup before install to imagedir"""
if ( os.path.exists( self.imageDir() ) ):
EmergeDebug.debug("cleaning image dir: %s" % self.imageDir(), 1)
utils.cleanDirectory( self.imageDir() )
os.rmdir(self.imageDir())
return True
def fetch( self, dummyRepopath = None ):
"""fetch normal tarballs"""
EmergeDebug.debug("ArchiveSource.fetch called", 2)
filenames = self.localFileNames()
if ( self.noFetch ):
EmergeDebug.debug("skipping fetch (--offline)")
return True
self.setProxy()
if self.subinfo.hasTarget():
if self.__checkFilesPresent(filenames):
EmergeDebug.debug("files and digests available, no need to download files", 1)
return True
result = utils.getFiles( self.subinfo.target(), EmergeStandardDirs.downloadDir() , filenames = self.subinfo.archiveName() )
if not result:
EmergeDebug.debug("failed to download files", 1)
return False
if result and self.subinfo.hasTargetDigestUrls():
if type(self.subinfo.targetDigestUrl()) == tuple:
url, alg = self.subinfo.targetDigestUrl()
return utils.getFiles(url, EmergeStandardDirs.downloadDir(),
filenames = self.subinfo.archiveName()
+ EmergeHash.HashAlgorithm.fileEndings().get(alg))
else:
return utils.getFiles( self.subinfo.targetDigestUrl(), EmergeStandardDirs.downloadDir(), filenames = '' )
else:
EmergeDebug.debug("no digestUrls present", 2)
return True
else:
return utils.getFiles( "", EmergeStandardDirs.downloadDir() )
def __init__(self):
EmergeDebug.debug("SetupPackageBase.__init__ called", 2)
PackageBase.__init__(self)
MultiSource.__init__(self)
BuildSystemBase.__init__(self)
PackagerBase.__init__(self)
self.subinfo.options.unpack.runInstaller = True
def __init__(self,
defaultType=eval(
emergeSettings.get("Packager", "PackageType",
"SevenZipPackager"))):
EmergeDebug.debug("TypePackager __init__ %s" % defaultType, 2)
PackagerBase.__init__(self)
self.__packager = defaultType
def unpack(self):
"""unpacking all zipped(gz, zip, bz2) tarballs"""
EmergeDebug.debug("ArchiveSource.unpack called", 2)
filenames = self.localFileNames()
# TODO: this might delete generated patches
utils.cleanDirectory(self.workDir())
if not self.checkDigest():
return False
binEndings = (".exe", ".bat", ".msi")
for filename in filenames:
if filename.endswith(binEndings):
filePath = os.path.abspath( os.path.join(EmergeStandardDirs.downloadDir(), filename) )
if self.subinfo.options.unpack.runInstaller:
_, ext = os.path.splitext( filename )
if ext == ".exe":
return utils.system("%s" % filePath )
elif ( ext == ".msi" ):
return utils.system("msiexec /package %s" % filePath )
if not utils.copyFile( filePath, os.path.join(self.workDir(), filename) ):
return False
else:
if not utils.unpackFile( EmergeStandardDirs.downloadDir(), filename, self.workDir()):
return False
ret = self.applyPatches()
if emergeSettings.getboolean("General","EMERGE_HOLD_ON_PATCH_FAIL",False):
return ret
return True
def sourceVersion(self):
""" return the revision of the repository """
EmergeDebug.trace("HgSource.sourceVersion called", 2)
if self.enableHg:
# open a temporary file - do not use generic tmpfile because this doesn't give a good file object with python
with open(
os.path.join(self.checkoutDir().replace('/', '\\'),
".emergehgtip.tmp"), "wb+") as tempfile:
# run the command
utils.system("%s tip" % self.hgExecutable, stdout=tempfile)
# TODO: check return value for success
tempfile.seek(os.SEEK_SET)
# read the temporary file and grab the first line
revision = tempfile.readline().replace("changeset:",
"").strip()
os.remove(
os.path.join(self.checkoutDir().replace('/', '\\'),
".emergehgtip.tmp"))
# always return True to not break something serious
return revision
def PackagerFactory(parent, packagerType):
"""provides multi packager type api
return PackagerBase derived instance for recent settings"""
EmergeDebug.debug("PackagerFactory called", 2)
packagers = []
if packagerType:
for packagerClass in packagerType:
if not issubclass(packagerClass, PackagerBase):
EmergeDebug.die("PackagerFactory: unsupported packager %s" %
packagerClass)
else:
packager = packagerClass()
init(packager, parent)
packagers.append(packager)
else:
# automatic detection
packager = InnoSetupPackager()
init(packager, parent)
if packager.configFile() != None:
packagers.append(packager)
# default packager
if len(packagers) == 0:
packager = KDEWinPackager()
init(packager, parent)
packagers.append(packager)
return packagers
def inner(*args, **argv):
logdir = emergeSettings.get( "General", "EMERGE_LOG_DIR", "" )
if logdir == "":
return fn(*args, **argv)
if os.path.isfile(logdir):
EmergeDebug.die("EMERGE_LOG_DIR %s is a file" % logdir)
if not os.path.exists(logdir):
try:
os.mkdir(logdir)
except OSError:
EmergeDebug.die("EMERGE_LOG_DIR %s can not be created" % logdir)
logfile = ""
for a in args:
logfile += "%s-" % a
logfile = logfile[:-1]#drop last -
logfile = "%s.log" % logfile.replace("/","_").replace("\\","_")
logfile = os.path.join(logdir, logfile)
f = open(logfile, "at")
try:
old_out = sys.stdout
old_err = sys.stderr
sys.stdout = f
sys.stderr = f
return fn(*args, **argv)
finally:
sys.stdout = old_out
sys.stderr = old_err
f.close()
def doExec(package, action, continueFlag=False):
with EmergeTimer.Timer("%s for %s" % (action, package), 1):
EmergeDebug.info("Action: %s for %s" % (action, package))
ret = package.execute(action)
if not ret:
EmergeDebug.warning("Action: %s for %s FAILED" % (action, package))
return ret or continueFlag
def getFiles( urls, destdir, suffix='' , filenames = ''):
"""download files from 'url' into 'destdir'"""
EmergeDebug.debug("getfiles called. urls: %s, filenames: %s, suffix: %s" % (urls, filenames, suffix), 1)
# make sure distfiles dir exists
if ( not os.path.exists( destdir ) ):
os.makedirs( destdir )
if type(urls) == list:
urlList = urls
else:
urlList = urls.split()
if filenames == '':
filenames = [ os.path.basename(x) for x in urlList ]
if type(filenames) == list:
filenameList = filenames
else:
filenameList = filenames.split()
dlist = list(zip( urlList , filenameList ))
for url,filename in dlist:
if ( not getFile( url + suffix, destdir , filename ) ):
return False
return True
def deleteFile(fileName):
"""delete file """
if not os.path.exists( fileName ):
return False
EmergeDebug.debug("delete file %s " % (fileName), 2)
os.remove( fileName )
return True
def getNightlyVersionsFromUrl(url, pattern, timeout = 10) -> [str]:
"""
Returns a list of possible version number matching the regular expression in pattern.
:param url: The url to look for the nightly builds.
:param pattern: A regular expression to match the version.
:param timeout:
:return: A list of matching strings or [None]
"""
if emergeSettings.getboolean("General", "WorkOffline"):
EmergeDebug.info("Nightly builds unavailable for %s in offline mode." % url)
return [None]
if url in UtilsCache._NIGTHLY_URLS:
return UtilsCache._NIGTHLY_URLS[url]
else:
try:
with urllib.request.urlopen(url, timeout = timeout) as fh:
data = str(fh.read(), "UTF-8")
vers = re.findall( pattern , data)
if not vers:
print(data)
raise Exception("Pattern %s does not match." % pattern)
UtilsCache._NIGTHLY_URLS[url] = vers
return vers
except Exception as e:
EmergeDebug.warning("Nightly builds unavailable for %s: %s" % (url, e))
return [None]
def __repositoryBaseUrl( self ):
""" this function return the base url to the KDE repository """
EmergeDebug.trace("VersionSystemSourceBase __repositoryBaseUrl", 2)
# @todo move to SvnSource
server = emergeSettings.get("General", "KDESVNSERVER", "svn://anonsvn.kde.org")
return server + '/home/kde/'
def setDependencies( self ):
EmergeDebug.debug("emergebuildsystem:subinfo.setDependencies not implemented yet", 1)
# we need at least qmake
#self.dependencies['libs/qt'] = 'default'
self.buildDependencies['dev-util/jom'] = 'default'
if compiler.isMinGW():
self.buildDependencies['dev-util/mingw-w64'] = 'default'
def applyPatch(self, fileName, patchdepth, unusedSrcDir=None):
"""apply a patch to a svn repository checkout"""
EmergeDebug.trace("SvnSource.applyPatch", 2)
if fileName:
return utils.applyPatch(self.sourceDir(),
os.path.join(self.packageDir(), fileName),
patchdepth)
return True
def notify(title,message,alertClass = None):
EmergeDebug.info("%s: %s" % (title, message))
backends = emergeSettings.get( "General","EMERGE_USE_NOTIFY", "")
if backends == "":
return
backends = Notifier.NotificationLoader.load(backends.split(";"))
for backend in backends.values():
backend.notify(title,message,alertClass)
def applyPatch(sourceDir, f, patchLevel='0'):
"""apply single patch"""
cmd = 'patch -d "%s" -p%s -i "%s"' % (sourceDir, patchLevel, f)
EmergeDebug.debug("applying %s" % cmd)
result = system( cmd )
if not result:
EmergeDebug.warning("applying %s failed!" % f)
return result
def systemWithoutShell(cmd, **kw):
"""execute cmd. All keywords are passed to Popen. stdout and stderr
might be changed depending on the chosen logging options."""
EmergeDebug.debug("executing command: %s" % cmd, 1)
if EmergeDebug.verbose() == -1 and not 'stdout' in kw and not 'stderr' in kw:
kw['stdout'] = kw['stderr'] = subprocess.DEVNULL
return subprocess.call(cmd, **kw) == 0
