def unpack( self ):
svnpath = self.kdeSvnPath()
utils.cleanDirectory( self.workdir )
if svnpath:
if not self.kdeSvnUnpack( svnpath, "scripts" ):
return False
for pkg in self.subinfo.languages.split():
if not self.kdeSvnUnpack( svnpath, pkg ):
return False
else:
print "Unpacked %s" % pkg
autogen = os.path.join( self.packagedir , "autogen.py" )
svnpath = os.path.join( self.kdesvndir, svnpath )
# execute autogen.py and generate the CMakeLists.txt files
cmd = "cd %s && python %s %s" % \
(svnpath , autogen, self.subinfo.languages )
utils.system( cmd )
else:
filenames = []
for pkg in self.subinfo.languages.split():
if not self.subinfo.buildTarget in self.subinfo.targets.keys():
return False
tgt = self.subinfo.buildTarget
filenames.append( 'kde-l10n-' + pkg + '-' + tgt + '.tar.bz2' )
if not utils.unpackFiles( self.downloaddir, filenames, self.workdir ):
return False
# no need for autogen.py - CMake scripts are already created
return True
def unpack( self ):
svnpath = self.kdeSvnPath()
utils.cleanDirectory( self.workdir )
if svnpath:
if not self.kdeSvnUnpack( svnpath, "scripts" ):
return False
for pkg in self.subinfo.languages.split():
if not self.kdeSvnUnpack( svnpath, pkg ):
return False
autogen = os.path.join( self.packagedir , "autogen.py" )
svnpath = os.path.join( self.kdesvndir, svnpath )
# execute autogen.py and generate the CMakeLists.txt files
cmd = [ "python", autogen, self.subinfo.languages ]
# FIXME comment out once libxslt works again
cmd.append( "--disable-docs" )
utils.system( cmd )
else:
filenames = []
for pkg in self.subinfo.languages.split():
if not self.subinfo.buildTarget in self.subinfo.targets.keys():
return False
tgt = self.subinfo.buildTarget
filenames.append( 'kde-l10n-' + pkg + '-' + tgt + '.tar.bz2' )
if not utils.unpackFiles( self.downloaddir, filenames, self.workdir ):
return False
# no need for autogen.py - CMake scripts are already created
return True
def destroyCraftRoot():
del InstallDB.installdb
root = CraftStandardDirs.craftRoot()
for entry in os.listdir(root):
path = os.path.join(root, entry)
if os.path.exists(CraftStandardDirs.etcDir()) and os.path.samefile(
path, CraftStandardDirs.etcDir()):
for entry in os.listdir(path):
if entry not in ["kdesettings.ini", "CraftSettings.ini"]:
etcPath = os.path.join(path, entry)
if os.path.isdir(etcPath):
if utils.OsUtils.isLink(etcPath):
print("Skipping symlink %s" % etcPath)
continue
utils.cleanDirectory(etcPath)
utils.OsUtils.rmDir(etcPath, True)
else:
utils.OsUtils.rm(etcPath, True)
elif not any(
os.path.exists(x) and os.path.samefile(path, x) for x in [
CraftStandardDirs.downloadDir(),
os.path.normpath(
os.path.join(CraftStandardDirs.craftBin(), "..")),
os.path.join(CraftStandardDirs.craftRoot(), "python")
]):
if utils.OsUtils.isLink(path):
print("Skipping symlink %s" % path)
continue
utils.cleanDirectory(path)
utils.OsUtils.rmDir(path, True)
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 kdeConfigureInternal( self, buildType, kdeCustomDefines ):
"""Using cmake"""
builddir = "%s" % ( self.COMPILER )
if( not buildType == None ):
buildtype = "-DCMAKE_BUILD_TYPE=%s" % buildType
builddir = "%s-%s" % ( builddir, buildType )
if( not self.buildNameExt == None ):
builddir = "%s-%s" % ( builddir, self.buildNameExt )
os.chdir( self.workdir )
if ( not os.path.exists( builddir) ):
os.mkdir( builddir )
if not self.noClean:
utils.cleanDirectory( builddir )
os.chdir( builddir )
command = r"""cmake -G "%s" %s %s %s""" % \
( self.cmakeMakefileGenerator, \
self.kdeDefaultDefines(), \
kdeCustomDefines, \
buildtype )
if utils.verbose() > 0:
print "configuration command: %s" % command
if not utils.system(command):
utils.die( "while CMake'ing. cmd: %s" % command )
return True
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 cleanImage(self) -> bool:
"""cleanup before install to imagedir"""
if (os.path.exists(self.imageDir())):
CraftCore.log.debug("cleaning image dir: %s" % self.imageDir())
utils.cleanDirectory(self.imageDir())
os.rmdir(self.imageDir())
return True
def unpack( self ):
if self.buildTarget == "svnHEAD":
if utils.verbose() >= 1:
print "libassuan unpack called"
# do the svn fetch/update
repo = "svn://cvs.gnupg.org/libassuan/trunk"
self.svnFetch( repo )
utils.cleanDirectory( self.workdir )
# now copy the tree below destdir/trunk to workdir
srcdir = os.path.join( self.svndir, "trunk" )
destdir = os.path.join( self.workdir, "libassuan" )
utils.copySrcDirToDestDir( srcdir, destdir )
os.chdir( self.workdir )
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "libassuan.diff" ) ) )
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "libassuan-cmake.diff" ) ) )
return True
else:
base.baseclass.unpack( self ) or utils.die( "unpack failed" )
os.chdir( self.workdir )
shutil.move("libassuan-1.0.5", "libassuan")
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "libassuan.diff" ) ) )
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "libassuan-cmake.diff" ) ) )
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "libassuan-unistd.diff" ) ) )
return True
def msysCompile( self, bOutOfSource = True ):
"""run configure and make for Autotools based stuff"""
config = os.path.join( self.workdir, self.instsrcdir, "configure" )
build = os.path.join( self.workdir )
if( bOutOfSource ):
# otherwise $srcdir is very long and a conftest may fail (like it's the
# case in libgmp-4.2.4)
config = os.path.join( "..", self.instsrcdir, "configure" )
build = os.path.join( build, self.instsrcdir + "-build" )
utils.cleanDirectory( build )
else:
build = os.path.join( build, self.instsrcdir )
sh = os.path.join( self.msysdir, "bin", "sh.exe" )
# todo use msysexecute
cmd = "%s --login -c \"cd %s && %s %s && make -j2" % \
( sh, self.__toMSysPath( build ), self.__toMSysPath( config ), \
self.msysConfigureFlags() )
if utils.verbose() > 1:
cmd += " VERBOSE=1"
cmd += "\""
if utils.verbose() > 0:
print "msys compile: %s" % cmd
if not utils.system(cmd):
utils.die( "msys compile failed. cmd: %s" % cmd )
return True
def cleanBuild(self) -> bool:
"""cleanup currently used build dir"""
if not self.subinfo.options.useShadowBuild:
return True
if os.path.exists(self.buildDir()):
utils.cleanDirectory(self.buildDir())
CraftCore.log.debug("cleaning build dir: %s" % self.buildDir())
return True
def install(self):
if not os.path.isdir( os.path.join( self.installDir() , "bin" ) ):
os.makedirs( os.path.join( self.installDir() , "bin" ) )
shutil.copy(os.path.join( self.imageDir() , "upx307w", "upx.exe"),
os.path.join( self.installDir() , "bin" , "upx.exe") )
utils.cleanDirectory( os.path.join( self.imageDir() , "upx307w" ) )
os.removedirs( os.path.join( self.imageDir() , "upx307w" ) )
return True
def install(self):
ver2 = self.subinfo.buildTarget.replace('.', '')
if not os.path.isdir( os.path.join( self.installDir() , "bin" ) ):
os.makedirs( os.path.join( self.installDir() , "bin" ) )
shutil.copy(os.path.join( self.imageDir() , "upx" + ver2 + "w", "upx.exe"),
os.path.join( self.installDir() , "bin" , "upx.exe") )
utils.cleanDirectory( os.path.join( self.imageDir() , "upx" + ver2 + "w" ) )
os.removedirs( os.path.join( self.imageDir() , "upx" + ver2 + "w" ) )
return True
def install(self):
ver2 = self.subinfo.buildTarget.replace('.', '')
if not os.path.isdir(os.path.join(self.installDir(), "bin")):
os.makedirs(os.path.join(self.installDir(), "bin"))
shutil.copy(
os.path.join(self.imageDir(), "upx" + ver2 + "w", "upx.exe"),
os.path.join(self.installDir(), "bin", "upx.exe"))
utils.cleanDirectory(os.path.join(self.imageDir(), "upx" + ver2 + "w"))
os.removedirs(os.path.join(self.imageDir(), "upx" + ver2 + "w"))
return True
def unpack( self ):
utils.cleanDirectory( self.workdir )
if not os.path.exists( os.path.join( self.workdir, "3rdparty", "include", "dbus" ) ):
os.makedirs( os.path.join( self.workdir, "3rdparty", "include", "dbus" ) )
utils.copySrcDirToDestDir( os.path.join( self.rootdir, "include", "dbus" ), os.path.join( self.workdir, "3rdparty", "include", "dbus" ) )
if not os.path.exists( os.path.join( self.workdir, "3rdparty", "include", "openssl" ) ):
os.makedirs( os.path.join( self.workdir, "3rdparty", "include", "openssl" ) )
utils.copySrcDirToDestDir( os.path.join( self.rootdir, "include", "openssl" ), os.path.join( self.workdir, "3rdparty", "include", "openssl" ) )
if not os.path.exists( os.path.join( self.workdir, "3rdparty", "lib" ) ):
os.makedirs( os.path.join( self.workdir, "3rdparty", "lib" ) )
re1 = re.compile(".*dbus-1.*")
re2 = re.compile(".*eay.*")
for filename in os.listdir( os.path.join( self.rootdir, "lib" ) ):
if re1.match( filename ) or re2.match( filename ):
src = os.path.join( self.rootdir, "lib", filename )
dst = os.path.join( self.workdir, "3rdparty", "lib", filename )
shutil.copyfile( src, dst )
# unpack our two external dependencies
# thirdparty_dir = os.path.join( self.workdir, "3rdparty" )
# files = [ os.path.basename( self.openssl ) ]
#ENTERPRISE4: we don't use the binary dbus packages
# files.append( os.path.basename( self.dbuslib ) )
# if not utils.unpackFiles( self.downloaddir, files, thirdparty_dir ):
# return False
# and now qt
if self.buildTarget == "4.4":
self.kdeSvnUnpack() or utils.die( "kdeSvnUnpack failed" )
else:
self.kdeSvnUnpack() or utils.die( "kdeSvnUnpack failed" )
# unpack all subdirs except 'include'
svnpath = os.path.join( self.kdesvndir, self.kdeSvnPath() )
for subdir in "bin config.tests demos doc examples lib mkspecs patches qmake src tools translations".split():
self.kdeSvnUnpack( self.kdeSvnPath(), subdir ) or utils.die( "kdeSvnUnpack failed" )
svnpath = os.path.join( self.kdesvndir, self.kdeSvnPath() )
if self.buildTarget == '4.4.3-3':
# use our configure.exe until tt has the patches upstream
src = os.path.join( self.packagedir, "configure.exe" )
dst = os.path.join( svnpath, "configure.exe" )
shutil.copyfile( src, dst )
# apply patches
os.chdir(svnpath)
cmd = "python apply_patches.py"
self.system( cmd )
return True
def make_package( self ):
# clean directory
dst = os.path.join( self.imagedir, self.instdestdir, "lib" )
utils.cleanDirectory( dst )
for lib in PACKAGE_DLL_NAME.split():
self.stripLibs( lib )
# auto-create both import libs with the help of pexports
for lib in PACKAGE_DLL_NAME.split():
self.createImportLibs( lib )
# now do packaging with kdewin-packager
self.doPackaging( PACKAGE_NAME, PACKAGE_FULL_VER, True )
return True
def cleanBuild(self) -> bool:
"""cleanup currently used build dir"""
if not self.subinfo.options.useShadowBuild:
return True
if os.path.exists(self.buildDir()):
return utils.cleanDirectory(self.buildDir())
return True
def deleteEntry(path):
if utils.OsUtils.isLink(path):
CraftCore.log.debug(f"Skipping symlink {path}")
return
if os.path.isdir(path):
if any(os.path.exists(x) and os.path.samefile(path, x) for x in maybeKeepDir):
CraftCore.log.debug(f"Path {path} in maybeKeepDir")
for entry in os.listdir(path):
deleteEntry(os.path.join(path, entry))
elif any(os.path.exists(x) and os.path.samefile(path, x) for x in dirsToKeep):
CraftCore.log.debug(f"Path {path} in dirsToKeep")
else:
utils.cleanDirectory(path)
utils.OsUtils.rmDir(path, True)
else:
if os.path.basename(path) not in settingsFiles:
utils.OsUtils.rm(path, True)
def install(self):
""" we have the whole logic here """
imageEtcDir = os.path.join(self.imageDir(), "etc")
installDBFile = os.path.join(imageEtcDir, "install.db")
settingsFile = os.path.join(imageEtcDir, "kdesettings.ini")
if os.path.exists(self.imageDir()):
utils.cleanDirectory(self.imageDir())
os.makedirs(imageEtcDir)
# get the current installdb and the kdesettings.ini file
utils.copyFile(os.path.join(EmergeStandardDirs.etcPortageDir(), "install.db"), installDBFile, linkOnly=False)
utils.copyFile(os.path.join(EmergeStandardDirs.etcDir(), "kdesettings.ini"), settingsFile, linkOnly=False)
self.resetSettings(settingsFile)
self.db = InstallDB(installDBFile)
self.removeCategoryFromDB("gnuwin32")
self.removeCategoryFromDB("dev-util")
# FIXME: the kdesettings file still contains packages that are not part of the frameworks sdk!!!
return True
def unpack( self ):
# print "gpgme-qt unpack called"
# do the svn fetch/update
repo = "svn://cvs.gnupg.org/gpgme/trunk/gpgme"
utils.cleanDirectory( self.workdir )
self.svnFetch( repo )
self.kdeSvnUnpack()
srcdir = os.path.join( self.svndir )
destdir = os.path.join( self.workdir, "kdepimlibs", "gpgme-qt" )
utils.copySrcDirToDestDir( srcdir, destdir )
os.chdir( self.workdir )
utils.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "gpgme-qt.patch" ) ) )
return True
def install( self ):
srcdir = self.sourceDir()
dstdir = self.installDir()
utils.cleanDirectory( dstdir )
os.makedirs (os.path.join (dstdir, "lib", "R"))
os.makedirs (os.path.join (dstdir, "bin"))
# place everything in dstdir/lib/R (similar to debian packaging)
portage.remInstalled( self.category, self.package, "stablelatest" )
utils.copyDir (srcdir, os.path.join (dstdir, "lib", "R"))
# create a shortcut in dstdir/bin
f = open(os.path.join (dstdir, "bin", "R.bat"), "w")
f.write("REM redirect to R.exe, autocreated during installation\n" + os.path.join ("%~dsp0", "..", "lib", "R", "bin", "R.exe") + " %1 %2 %3 %4 %5 %6 %7 %8 %9\n")
f.close()
return True
def unpack( self ):
utils.cleanDirectory( self.buildDir() )
self.enterBuildDir()
print self.buildDir()
thirdparty_dir = os.path.join( self.buildDir(), "3rdparty" )
utils.createDir(thirdparty_dir)
if not utils.unpackFile( self.downloadDir(), os.path.basename(self.openssl), thirdparty_dir ):
return False
if not utils.unpackFile( self.downloadDir(), os.path.basename(self.dbuslib), thirdparty_dir ):
return False
if not utils.unpackFile( self.downloadDir(), os.path.basename(self.mysql), thirdparty_dir ):
return False
return True
def initializePaths(logger, packageName):
"""Assign and initialize temp directories for this work."""
packageBasePath = os.path.join(env.runTimePath, 'packages', packageName)
newPackagePath = os.path.join(packageBasePath, 'new')
oldPackagePath = os.path.join(packageBasePath, 'old')
if os.path.isdir(packageBasePath):
## Remove previous package version before creating new artifacts
logger.info('Removing previous directory on server: {}'.format(packageBasePath))
utils.cleanDirectory(logger, packageBasePath)
time.sleep(.1)
if os.path.isdir(packageBasePath):
raise EnvironmentError('Failed to clean previous directory on server: {}. Unable to continue with package operation.'.format(packageBasePath))
os.makedirs(packageBasePath)
os.mkdir(newPackagePath)
os.mkdir(oldPackagePath)
## end initializePaths
return (packageBasePath, newPackagePath, oldPackagePath)
def unpack( self ):
print "gpgme-qt unpack called"
# do the svn fetch/update
if self.buildTarget == 'svnHEAD':
repo = "svn://cvs.gnupg.org/gpgme/trunk/gpgme"
self.svnFetch( repo )
utils.cleanDirectory( self.workdir )
# now copy the tree below destdir/trunk to workdir
utils.debug( "%s %s" % ( self.svndir, self.workdir ) )
srcdir = os.path.join( self.svndir )
destdir = os.path.join( self.workdir, "gpgme-qt" )
utils.copySrcDirToDestDir( srcdir, destdir )
else:
if( not base.baseclass.unpack( self ) ):
return True
os.chdir( self.workdir )
self.system( "cd %s && patch -p0 < %s" % ( self.workdir, os.path.join( self.packagedir, "gpgme-qt.patch" ) ) )
return True
def destroyEmergeRoot():
del InstallDB.installdb
root = EmergeStandardDirs.emergeRoot()
for entry in os.listdir(root):
path = os.path.join(root, entry)
if path == EmergeStandardDirs.etcDir():
for entry in os.listdir(path):
if not entry == "kdesettings.ini":
etcPath = os.path.join(path, entry)
if os.path.isdir(etcPath):
utils.cleanDirectory(etcPath)
utils.OsUtils.rmDir(etcPath, True)
else:
utils.OsUtils.rm(etcPath, True)
elif not path in [
EmergeStandardDirs.downloadDir(),
EmergeStandardDirs.emergeRepositoryDir(),
os.path.join(EmergeStandardDirs.emergeRoot(), "python")
]:
utils.cleanDirectory(path)
utils.OsUtils.rmDir(path, True)
def install(self):
""" we have the whole logic here """
imageEtcDir = os.path.join(self.imageDir(), "etc")
installDBFile = os.path.join(imageEtcDir, "install.db")
settingsFile = os.path.join(imageEtcDir, "kdesettings.ini")
if os.path.exists(self.imageDir()):
utils.cleanDirectory(self.imageDir())
os.makedirs(imageEtcDir)
# get the current installdb and the kdesettings.ini file
utils.copyFile(os.path.join(EmergeStandardDirs.etcPortageDir(),
"install.db"),
installDBFile,
linkOnly=False)
utils.copyFile(os.path.join(EmergeStandardDirs.etcDir(),
"kdesettings.ini"),
settingsFile,
linkOnly=False)
self.resetSettings(settingsFile)
self.db = InstallDB(installDBFile)
self.removeCategoryFromDB("gnuwin32")
self.removeCategoryFromDB("dev-util")
# FIXME: the kdesettings file still contains packages that are not part of the frameworks sdk!!!
return True
def removePackage(packageName):
globalSettings = utils.loadSettings(os.path.join(env.configPath, 'globalSettings.json'))
logger = utils.setupLogger('Packages', env, globalSettings['fileContainingCoreLogSettings'])
dbClient = getDbConnection(logger)
try:
logger.info('Searching for package in database: {}'.format(packageName))
dbClass = platformSchema.ContentPackage
package = dbClient.session.query(dbClass).filter(dbClass.name == packageName).first()
if package is None:
logger.info('Package {} not found in database... nothing to do.'.format(packageName))
else:
logger.info('Removing package files...'.format(packageName))
dbClient.session.commit()
## Remove all files first
removeFiles(logger, dbClient, packageName)
## And now remove the package
package = dbClient.session.query(dbClass).filter(dbClass.name == packageName).first()
packageType = package.system
dbClient.session.delete(package)
dbClient.session.commit()
## Remove from filesystem
packageSystemPath = validPackageSystems[pkgSystem.lower()]['path']
packagePath = os.path.join(packageSystemPath, packageName)
logger.info('Removing files from server directory: {}...'.format(packagePath))
utils.cleanDirectory(logger, packagePath)
logger.info('Package {} removed.'.format(packageName))
except:
stacktrace = traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
logger.error('Exception in removePackage: {}'.format(stacktrace))
with suppress(Exception):
dbClient.session.close()
dbClient.close()
## end removePackage
return
def install( self ):
workdir = os.path.join( self.workdir, self.instsrcdir )
utils.cleanDirectory( os.path.join( self.imagedir, "bin" ) )
utils.cleanDirectory( os.path.join( self.imagedir, "lib" ) )
utils.cleanDirectory( os.path.join( self.imagedir, "include" ) )
# instead of being written to out32dll the dll's go to the root - this might change
shutil.copy( os.path.join( workdir, "libeay32.dll" ), os.path.join( self.imagedir, "bin" ) )
shutil.copy( os.path.join( workdir, "libssl32.dll" ), os.path.join( self.imagedir, "bin" ) )
if self.compiler == "mingw":
shutil.copy( os.path.join( workdir, "out", "libeay32.a" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libssl32.a" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libcrypto.a" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libssl.a" ), os.path.join( self.imagedir, "lib" ) )
else:
# this is not tested yet - I have no msvc build currently
shutil.copy( os.path.join( workdir, "out", "libeay32.lib" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libssl32.lib" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libcrypto.lib" ), os.path.join( self.imagedir, "lib" ) )
shutil.copy( os.path.join( workdir, "out", "libssl.lib" ), os.path.join( self.imagedir, "lib" ) )
shutil.copytree( os.path.join( workdir, "outinc", "openssl" ), os.path.join( self.imagedir, "include", "openssl" ) )
return True
mingw
msys
openssl
perl
pexports
ruby
subversion
wget
upx"""
for package in packages.split():
print "removing package %s" % package
utils.system("emerge --unmerge %s" % package)
# remove all temporary files
utils.system("emerge --cleanbuild %s" % package)
#clean directory
utils.cleanDirectory(os.path.join(rootdir,'dev-utils'))
# reinstall packages
utils.system("emerge --update wget")
utils.system("emerge --update base")
done = True
elif currentVersion == '20090808':
utils.system("emerge --unmerge subversion")
utils.system("emerge --qmerge subversion")
done = True
if done:
with open( versionFile, "w" ) as f:
f.write(newVersion)
def cleanDir(dir):
if os.path.isdir(dir):
CraftCore.log.info(f"Cleaning: {dir}")
utils.cleanDirectory(dir)
utils.rmtree(dir)
def install( self ):
self.instsrcdir = PACKAGE_INSTSRCDIR
# cleanup
dst = os.path.join( self.imagedir )
utils.cleanDirectory( dst )
dst = os.path.join( self.imagedir, self.instdestdir )
utils.cleanDirectory( dst )
# /bin can be used from zip package
src = os.path.join( self.workdir, self.instsrcdir, "bin" )
dst = os.path.join( self.imagedir, self.instdestdir, "bin" )
utils.copySrcDirToDestDir( src, dst )
# /include can be used from zip package
src = os.path.join( self.workdir, self.instsrcdir, "include" )
dst = os.path.join( self.imagedir, self.instdestdir, "include" )
utils.copySrcDirToDestDir( src, dst )
# /contrib contains readme.txt
dst = os.path.join( self.imagedir, self.instdestdir, "contrib" )
utils.cleanDirectory( dst )
dst = os.path.join( dst, PACKAGE_NAME )
utils.cleanDirectory( dst )
dst = os.path.join( dst, PACKAGE_FULL_VER )
utils.cleanDirectory( dst )
src = os.path.join( self.workdir, self.instsrcdir )
shutil.copy( os.path.join( src, "readme.txt" ), os.path.join( dst, "readme.txt" ) )
# /lib needs a complete rebuild - done in make_package
src = os.path.join( self.workdir, self.instsrcdir, "lib" )
dst = os.path.join( self.imagedir, self.instdestdir, "lib" )
utils.cleanDirectory( dst )
# no need to recreate msvc import lib
shutil.copy( os.path.join( src, PACKAGE_DLL_NAME + ".lib" ), os.path.join( dst, PACKAGE_DLL_NAME + ".lib" ) )
return True
stayQuiet = True
elif ( i == "--disable-buildhost" ):
disableHostBuild = True
elif ( i == "--disable-buildtarget" ):
disableTargetBuild = True
elif( i == "--cleanup" ):
utils.debug("Starting to clean emerge" )
utils.system("cd %s && git clean -f -x -e *.py -e *.diff -e *.ba\\t -e *.cmd -e *.reg" % os.path.join(os.getenv("KDEROOT"),"emerge") )
exit(0)
elif( i == "--cleanup-dry" ):
utils.debug("Starting to clean emerge" )
utils.system("cd %s && git clean --dry-run -x -e *.py -e *.diff -e *.ba\\t -e *.cmd -e *.reg" % os.path.join(os.getenv("KDEROOT"),"emerge") )
exit(0)
elif i == "--cleanallbuilds":
# clean complete build directory
utils.cleanDirectory(os.path.join( os.getenv("KDEROOT"), "build"))
exit(0)
elif ( i.startswith( "-" ) ):
usage()
exit ( 1 )
else:
packageName = i
break
if stayQuiet == True:
utils.setVerbose(0)
# get KDEROOT from env
KDEROOT = os.getenv( "KDEROOT" )
utils.debug( "buildAction: %s" % mainBuildAction )
utils.debug( "doPretend: %s" % doPretend, 1 )
def validatePackage(packageName, compressedFile, pkgSystem='contentGathering', forceUpdate=False):
"""Entry function.
Arguments:
compressedFile (str) : fully qualified package to be deployed
forceUpdate (bool) : whether to force update if package already exists
pkgSystem (str) : package type (target system/service to deploy into)
"""
globalSettings = utils.loadSettings(os.path.join(env.configPath, 'globalSettings.json'))
logger = utils.setupLogger('Packages', env, globalSettings['fileContainingCoreLogSettings'])
dbClient = getDbConnection(logger)
try:
## Check the extension
(pkgName, pkgExtension) = compressedFile.split('.')
if pkgExtension.lower() != 'zip' and pkgExtension.lower() != 'tar':
raise EnvironmentError('Content management expecting package in either ZIP or TAR format; unable to work with this format: {}.'.format(pkgExtension))
## Initialize directories for this work
(packageBasePath, newPackagePath, oldPackagePath) = initializePaths(logger, packageName)
## Check the target system for this package
if pkgSystem.lower() not in validPackageSystems:
raise EnvironmentError('Content management expecting package for a valid system {}, but received unknown type: {}.'.format(validPackageSystems, pkgType))
packageSystemName = validPackageSystems[pkgSystem.lower()]['name']
packageSystemPath = validPackageSystems[pkgSystem.lower()]['path']
## Extract contents into a temp runtime directory
extractContents(logger, compressedFile, packageName, pkgExtension, packageBasePath, newPackagePath)
## If package is in the database already, extract into side-by-side path
pkgExists = getContentPackage(logger, dbClient, oldPackagePath, packageName, stripString='content,{},{}'.format(packageSystemName, packageName))
if pkgExists:
## Compare the files with filecmp/difflib and present differences...
changes = []
comparePackageVersions(logger, packageName, oldPackagePath, newPackagePath, changes)
if len(changes) <= 0:
logger.info('No changes found; package {} remains unchanged.'.format(packageName))
else:
logger.info('Changes found in package {}, with the following files: {}'.format(packageName, str(changes)))
if not forceUpdate:
logger.info('Leaving package unchanged because the forceUpdate flag was not set.')
print('Leaving package unchanged because the forceUpdate flag was not set.')
else:
logger.info('Overwriting previous version...')
print('Overwriting previous version...')
loadPackageIntoDB(logger, packageName, packageSystemName, ['content', packageSystemName], dbClient, newPackagePath)
else:
## First time load of the package into the database
logger.info('Attempting to load new package into database...')
loadPackageIntoDB(logger, packageName, packageSystemName, ['content', packageSystemName], dbClient, newPackagePath)
## Cleanup
logger.info('Finished content management work on package {}; cleaning up.'.format(packageName))
utils.cleanDirectory(logger, packageBasePath)
except:
stacktrace = traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2])
logger.error('Exception in validatePackage: {}'.format(str(stacktrace)))
with suppress(Exception):
dbClient.session.close()
dbClient.close()
## end validatePackage
return
def cleanup( self ):
"""cleanup before install to imagedir"""
if ( os.path.exists( self.imagedir ) ):
utils.debug( "cleaning image dir: %s" % self.imagedir, 1 )
utils.cleanDirectory( self.imagedir )
return True
def cleanDir(dir):
CraftCore.debug.printOut(f"Cleaning: {dir}")
utils.cleanDirectory(dir)
os.rmdir(dir)
def cleanImage(self) -> bool:
"""cleanup before install to imagedir"""
if os.path.exists(self.imageDir()):
return utils.cleanDirectory(self.imageDir())
return True
