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 run_once(self): # check if the screensaver process is running and alive try: utils.system('export DISPLAY=:0.0 && xscreensaver-command -version') except error.CmdError, e: logging.debug(e) raise error.TestFail('xscreensaver is not alive')
def run_once(self, binary = '/opt/google/chrome/chrome'): # Try to kill all running instances of the binary. try: utils.system('pkill -KILL -f %s' % binary) except error.CmdError, e: logging.debug(e) raise error.TestFail('%s is not running before kill' % binary)
def failure_epilogue (self): if expected: print("Could not stat {} - was expected to be present".format(rootfs)) else: print("Sliver rootfs {} still present - this is unexpected".format(rootfs)) utils.system(self.test_ssh.actual_command("ls -l {rootfs}; du -hs {rootfs}".format(**locals()), dry_run=self.dry_run, timeout=20))
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 dld_genome_data( fname, url_prefix='ftp://ftp.ncbi.nih.gov/genomes/Bacteria/' ): bname = os.path.basename( fname ) ## e.g. NC_002937 try: os.makedirs( 'GENOMES' ) except: pass if not os.path.isfile( 'GENOMES/' + bname + '.gff' ): try: os.remove('GENOMES/' + bname + '.gff'); os.remove('GENOMES/' + bname + '.fna'); except: pass os.chdir( 'GENOMES' ) cmd = "wget '" + url_prefix + fname + ".gff'" tmp = ut.system( cmd ) cmd = "wget '" + url_prefix + fname + ".fna'" tmp = ut.system( cmd ) myfile = open( bname + '.fna', 'r' ) line = myfile.readline() myfile.close() cmd = "../rpl '" + line.strip() + "' '>" + line.split('|')[3] + "' " + bname + '.fna' tmp = ut.system( cmd ) ut.system( "awk '($3==\"gene\"){print}' " + bname + ".gff > " + bname + "_genes.gff" ) os.chdir( '..' )
def qemu_local_init(self): "all nodes : init a clean local directory for holding node-dep stuff like iso image..." utils.system("rm -rf {}".format(self.nodedir())) utils.system("mkdir {}".format(self.nodedir())) if not self.is_qemu(): return True return utils.system("rsync -v -a --exclude .svn template-qemu/ {}/"\ .format(self.nodedir())) == 0
def make( self ): build, bt, toolsetSwitches = self.getBuildSettings(); return utils.system("msbuild /target:lib_mpir_gc \"%s\" /p:Configuration=%s %s" % (os.path.join(self.sourceDir(), build, "mpir.sln"), bt, toolsetSwitches) ) and utils.system("msbuild /target:dll_mpir_gc \"%s\" /p:Configuration=%s %s" % (os.path.join(self.sourceDir(), build, "mpir.sln"), bt, toolsetSwitches) )
def compile( self ): if self.compiler == "mingw": compiler = "mingw32" else: compiler = "do_ms" workdir = os.path.join( self.workdir, self.instsrcdir ) cmd = 'cd %s && ms\\%s' % ( workdir, compiler ) print cmd utils.system( cmd ) or utils.die( "failed on command: %s" % cmd ) return True
def compile( self ): cmd = 'cd %s && python configure.py -b %s -w' % ( os.path.join( self.workdir, self.instsrcdir ), os.path.join( self.imagedir, "bin" ) ) if self.compiler == "mingw": cmd += " -p win32-g++" utils.system( cmd ) or utils.die( "failed to execute %s" % cmd ) sedcommand = r""" -e "s/""" + os.path.join( self.rootdir, "tmp", "qt" ).replace('\\', '\\/') + "*\\/image-mingw\\/" + """/""" + self.rootdir.replace('\\', '\\/') + """/g" """ utils.sedFile( os.path.join( self.workdir, self.instsrcdir ), "pyqtconfig.py", sedcommand ) cmd = 'cd %s && %s' % ( os.path.join( self.workdir, self.instsrcdir ), self.cmakeMakeProgramm ) utils.system( cmd ) or utils.die( "failed to execute %s" % cmd ) return True
def __init__( self, parent=None ): self.parent = self if parent: self.parent = parent self.output = False self.outFile = None self.graphVizInstallPath = None if not self.isInstalled(): utils.system("emerge.bat graphviz") if not self.isInstalled(): utils.die("could not find installed graphviz package, you may download and install it from http://www.graphviz.org/Download.php")
def install( self ): if self.isTargetBuild(): # Configuring Qt for WinCE ignores the -prefix option, # so we have to do the job manually... # delete this because it is not working for windows utils.deleteFile( os.path.join( self.buildDir(), "plugin", "bearer", "qnmbearerd4.dll" )) utils.deleteFile( os.path.join( self.buildDir(), "plugin", "bearer", "qnmbearer4.dll" )) # syncqt expects qconfig.h to be in the install dir and fails if not utils.createDir( os.path.join( self.installDir(), "src", "corelib", "global") ) utils.copyFile( os.path.join( self.buildDir(), "src", "corelib", "global", "qconfig.h" ), os.path.join( self.installDir(), "src", "corelib" , "global", "qconfig.h" ) ) # headers need to be copied using syncqt because of the relative paths utils.prependPath(self.sourceDir(), "bin") command = os.path.join(self.sourceDir(), "bin", "syncqt.bat") command += " -base-dir \"" + self.sourceDir() + "\"" command += " -outdir \"" + self.installDir() + "\"" command += " -copy" command += " -quiet" utils.system( command ) utils.copySrcDirToDestDir( os.path.join( self.buildDir(), "bin" ) , os.path.join( self.installDir(), "bin" ) ) utils.copySrcDirToDestDir( os.path.join( self.buildDir(), "lib" ) , os.path.join( self.installDir(), "lib" ) ) # the dlls must be copied to the bin dir too for file in os.listdir( os.path.join( self.installDir(), "lib" ) ): if file.endswith( ".dll" ): utils.copyFile( os.path.join( self.installDir(), "lib" , file ), os.path.join( self.installDir(), "bin" , file ) ) utils.copySrcDirToDestDir( os.path.join( self.buildDir(), "mkspecs" ) , os.path.join( self.installDir(), "mkspecs" ) ) utils.copySrcDirToDestDir( os.path.join( self.buildDir(), "plugins" ) , os.path.join( self.installDir(), "plugins" ) ) # create qt.conf utils.copyFile( os.path.join( self.packageDir(), "qt.conf" ), os.path.join( self.installDir(), "bin", "qt.conf" ) ) return True if not QMakeBuildSystem.install(self): return False # Workaround QTBUG-12034 utils.copySrcDirToDestDir( os.path.join( self.buildDir(), "plugins", "imageformats" ) , os.path.join( self.installDir(), "bin", "imageformats" ) ) # create qt.conf utils.copyFile( os.path.join( self.packageDir(), "qt.conf" ), os.path.join( self.installDir(), "bin", "qt.conf" ) ) # install msvc debug files if available if self.buildType() == "Debug" and (self.compiler() == "msvc2005" or self.compiler() == "msvc2008" or self.compiler() == "msvc2010"): srcdir = os.path.join( self.buildDir(), "lib" ) destdir = os.path.join( self.installDir(), "lib" ) filelist = os.listdir( srcdir ) for file in filelist: if file.endswith( ".pdb" ): utils.copyFile( os.path.join( srcdir, file ), os.path.join( destdir, file ) ) return True
def some_zeroed_input_file(self, prefix, mbytes): name = os.path.join(self.workdir, '%s%d' % (prefix, self.input_file_count)) self.input_file_count += 1 # TODO: use actual disk file size, avoid rebuilding across iterations old_mbytes = self.existing_input_files.get(name, 0) if mbytes > old_mbytes: cmd = ('/bin/dd if=/dev/zero of=%s bs=1M seek=%d count=%d' % (name, old_mbytes, mbytes-old_mbytes)) utils.system(cmd) self.existing_input_files[name] = mbytes return name
def patch(): os.chdir(utils.mojo_root_dir) utils.filter_file("build/landmines.py", lambda line: not "gyp" in line) utils.commit("filter gyp out of build/landmines.py") utils.filter_file("gpu/BUILD.gn", lambda line: not "//gpu/ipc" in line) utils.commit("filter gpu/ipc out of gpu/BUILD.gn") for p in utils.find(["*.patch"], os.path.dirname(os.path.realpath(__file__))): print "applying patch %s" % os.path.basename(p) utils.system(["git", "apply", p]) utils.commit("applied patch %s" % os.path.basename(p))
def make_package( self ): self.svnpath = os.path.join( self.kdesvndir, self.subinfo.svnTargets['svnHEAD'] ) dstpath = self.packageDestinationDir(withBuildType=False) if not utils.test4application( "kdewin-packager" ): utils.die( "kdewin-packager not found - please make sure it is in your path" ) for pkg in self.subinfo.languages.split(): workdir = os.path.join( self.workdir, pkg ) cmd = "kdewin-packager -name kde-l10n-%s -version %s -hashfirst -compression 2 -root %s/%s -destdir %s" % \ ( pkg, self.buildTarget, self.imagedir, pkg, dstpath ) utils.system( cmd ) return True
def kill_slower_workers(fast_pid, cpu_cgroup, pids_file): moved_pids_file = pids_file + '.moved' try: os.rename(pids_file, moved_pids_file) except OSError: return logging.debug('fastest worker pid %d of container %s' ' killing all slower workers', fast_pid, cpu_cgroup.path) for line in open(moved_pids_file): pid = int(line.rstrip()) if pid != fast_pid: utils.system('kill %d' % pid, ignore_status=True)
def install(self): srcdir = os.path.join(self.workdir, os.getenv("KDECOMPILER") + "-" + self.buildType, "wincursors") destdir = os.path.join(self.cmakeInstallPrefix, "share", "icons") utils.copySrcDirToDestDir(srcdir, destdir) srcreg = os.path.join(self.packagedir, "cursor.reg") dstreg = os.path.join(self.workdir, "cursor.reg") shutil.copy(srcreg, dstreg) utils.sedFile( self.workdir, "cursor.reg", "s/CHANGEME/%s/g" % destdir.replace("\\", "\\\\\\\\").replace("/", "\\\\\\\\") ) utils.system("regedit /S %s" % os.path.join(self.workdir, "cursor.reg")) return True
def sedFile(self, directory, fileName, sedcommand ): """ runs the given sed command on the given file """ olddir = os.getcwd() try: os.chdir( directory ) backup = "%s.orig" % fileName if( os.path.isfile( backup ) ): os.remove( backup ) command = "sed -i.orig %s %s" % ( sedcommand, fileName ) utils.system( command ) finally: os.chdir( olddir )
def configure( self, buildType=None, defines=""): thirdparty_dir = os.path.join( self.buildDir(), "3rdparty" ) utils.prependPath(self.buildDir(), "bin") configure = os.path.join( self.sourceDir(), "configure.exe" ).replace( "/", "\\" ) self.enterBuildDir() # so that the mkspecs can be found, when -prefix is set os.putenv( "QMAKEPATH", self.sourceDir() ) # configure qt # prefix = os.path.join( self.rootdir, "qt" ).replace( "\\", "/" ) prefix = self.installDir() platform = "" libtmp = os.getenv( "LIB" ) inctmp = os.getenv( "INCLUDE" ) if self.compiler() == "msvc2005" or self.compiler() == "msvc2008": platform = "win32-%s" % self.compiler() elif self.compiler() == "mingw": os.environ[ "LIB" ] = "" os.environ[ "INCLUDE" ] = "" platform = "win32-g++" else: exit( 1 ) os.environ[ "USERIN" ] = "y" userin = "y" command = r"echo %s | %s -opensource -platform %s -prefix %s " \ "-qt-gif -qt-libpng -qt-libjpeg -qt-libtiff -plugin-sql-mysql " \ "-no-phonon -qdbus -openssl -dbus-linked " \ "-fast -no-vcproj -no-dsp -plugin-sql-mysql " \ "-nomake demos -nomake examples -nomake docs " \ "-I \"%s\" -L \"%s\" " % \ ( userin, configure, platform, prefix, os.path.join( thirdparty_dir, "include" ), os.path.join( thirdparty_dir, "lib" ) ) if self.buildType() == "Debug": command = command + " -debug " else: command = command + " -release " print "command: ", command utils.system( command ) if( not libtmp == None ): os.environ[ "LIB" ] = libtmp if( not inctmp == None ): os.environ[ "INCLUDE" ] = inctmp return True
def unittest( self ): os.chdir( os.path.join( self.sourceDir(), 'build.vc12') ) if self.buildType() == "Debug": bt = "Debug" else: bt = "Release" toolsetSwitches = "" if compiler.isMSVC2012(): toolsetSwitches = "/property:PlatformToolset=v110" elif compiler.isMSVC2013(): toolsetSwitches = "/tv:12.0 /property:PlatformToolset=v120" return utils.system("msbuild \"%s\" /p:Configuration=%s %s" % (os.path.join(self.sourceDir(), "build.vc12", "mpir-tests.sln"), bt, toolsetSwitches) ) and utils.system(os.path.join("mpir-tests", "run-tests.py"));
def do_ssh_slice_once(self, options, command, expected): # locate a key private_key=self.locate_private_key() if not private_key : utils.header("WARNING: Cannot find a valid key for slice {}".format(self.name())) return False # convert nodenames to real hostnames slice_spec = self.slice_spec nodename=slice_spec['nodenames'][0] site_spec, node_spec = self.test_plc.locate_node(nodename) hostname=node_spec['node_fields']['hostname'] if expected: msg="{} to return TRUE from ssh".format(command) else: msg="{} to return FALSE from ssh".format(command) utils.header("checking {} -- slice {} on node {}".format(msg, self.name(), hostname)) site_spec, node_spec = self.test_plc.locate_hostname(hostname) test_ssh = TestSsh (hostname, key=private_key, username=self.name()) full_command = test_ssh.actual_command(command) retcod = utils.system (full_command, silent=True, timeout=10) if getattr(options, 'dry_run', None): return True if expected: success = retcod==0 else: success = retcod!=0 if not success: utils.header ("WRONG RESULT for {}".format(msg)) return success
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 run(self, silent): command = self.test_ssh.actual_command(self.command) retcod = utils.system(command, silent=silent, dry_run=self.dry_run) if self.expected: return retcod == 0 else: return retcod != 0
def createPortablePackage( self ): """create portable 7z package with digest files located in the manifest subdir""" if not self.packagerExe: utils.die("could not find 7za in your path!") if self.package.endswith( "-package" ): shortPackage = self.package[ : -8 ] else: shortPackage = self.package if not "setupname" in self.defines or not self.defines[ "setupname" ]: self.defines[ "setupname" ] = shortPackage if self.subinfo.options.package.withArchitecture: self.defines[ "setupname" ] += "-" + os.getenv("EMERGE_ARCHITECTURE") self.defines[ "setupname" ] += "-" + self.buildTarget + ".7z" if not "srcdir" in self.defines or not self.defines[ "srcdir" ]: self.defines[ "srcdir" ] = self.imageDir() for f in self.scriptnames: utils.copyFile(f,os.path.join(self.defines[ "srcdir" ],os.path.split(f)[1])) # make absolute path for output file if not os.path.isabs( self.defines[ "setupname" ] ): dstpath = self.packageDestinationDir() self.defines[ "setupname" ] = os.path.join( dstpath, self.defines[ "setupname" ] ) utils.deleteFile(self.defines[ "setupname" ]) cmd = "cd %s && %s a -r %s %s" % (self.defines[ "srcdir" ], self.packagerExe,self.defines[ "setupname" ], '*') if not utils.system(cmd): utils.die( "while packaging. cmd: %s" % cmd )
def make(self): self.enterSourceDir() if self.buildType() == "Debug": bt = "Debug" else: bt = "Release" datafile = os.path.join(os.path.dirname(os.path.abspath(__file__)), "icudt55l.dat") if os.path.exists(datafile): datafileDestination = os.path.join(self.sourceDir(), "data", "in", "icudt55l.dat") if os.path.exists(datafileDestination): os.remove(datafileDestination) utils.copyFile( datafile, datafileDestination) toolsetSwitches = "" if compiler.isMSVC2012(): toolsetSwitches = "/property:PlatformToolset=v110" elif compiler.isMSVC2013(): toolsetSwitches = "/tv:12.0 /property:PlatformToolset=v120" elif compiler.isMSVC2015(): toolsetSwitches = "/tv:14.0 /property:PlatformToolset=v140" return utils.system("msbuild /m /t:Rebuild \"%s\" /p:Configuration=%s %s" % (os.path.join(self.sourceDir(), "allinone", "allinone.sln"), bt, toolsetSwitches) )
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 run(self, command, message=None, background=False, dry_run=False): local_command = self.actual_command(command, dry_run=dry_run) if dry_run: utils.header("DRY RUN " + local_command) return 0 else: self.header(message) return utils.system(local_command, background)
def qmerge(self): if not BinaryPackageBase.qmerge(self): return False tmpFile = tempfile.TemporaryFile() git = os.path.join(self.rootdir,"dev-utils","git","bin","git") utils.system( "%s config --global --get url.git://anongit.kde.org/.insteadof" % git, stdout=tmpFile, stderr=tmpFile ) tmpFile.seek( 0 ) for line in tmpFile: if str(line,'UTF-8').find("kde:")>-1: return True utils.debug( "adding kde related settings to global git config file",1 ) utils.system( "%s config --global url.git://anongit.kde.org/.insteadOf kde:" % git) utils.system( "%s config --global url.ssh://[email protected]/.pushInsteadOf kde:" % git) utils.system( "%s config --global core.autocrlf false" % git) utils.system( "%s config --system core.autocrlf false" % git) 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 configure( self ): self.enterSourceDir() cmd = "python configure.py" cmd += self.subinfo.options.configure.defines cmd += " --bindir %s/bin " % self.installDir() cmd += " --destdir %s/Lib/site-packages " % self.installDir() cmd += " --plugin-destdir %s/plugins " % self.installDir() sipcfg = sipconfig.Configuration() sipdir = os.path.splitdrive(sipcfg.default_sip_dir)[1] sipdir = os.path.join(sipdir,'PyQt4') cmd += " --sipdir %s%s " % (self.installDir(), sipdir) utils.system(cmd) or utils.die("command: %s failed" % (cmd)) return True
def curlFile(url, destdir, filename, quiet): """download file with curl from 'url' into 'destdir', if filename is given to the file specified""" curl = CraftCore.cache.findApplication("curl") command = [curl, "-C", "-", "--retry", "10", "-L", "--ftp-ssl", "--fail"] cert = os.path.join(CraftCore.standardDirs.etcDir(), "cacert.pem") if os.path.exists(cert): command += ["--cacert", cert] # the default of 20 might not be enough for sourceforge ... command += ["--max-redirs", "50"] command += ["-o", os.path.join(destdir, filename)] command += [url] CraftCore.log.debug("curlfile called") if CraftCore.debug.verbose() < 1: if quiet: with io.StringIO() as tmp: ciMode = CraftCore.settings.getboolean("ContinuousIntegration", "Enabled", False) if ciMode: command += ["-v"] if not utils.system(command, logCommand=ciMode, stdout=tmp, stderr=subprocess.STDOUT): CraftCore.log.warning(tmp.getvalue()) return False if ciMode: loc = re.findall(r"Host: ([^\s]+)", tmp.getvalue()) if loc: CraftCore.log.info(f"Downloaded from: {loc[-1]}") return True elif CraftCore.cache.checkCommandOutputFor(curl, "--progress-bar", helpCommand="--help all"): command += ["--progress-bar"] CraftCore.log.info(f"curl {url}") return utils.system(command, displayProgress=True, logCommand=False, stderr=subprocess.STDOUT) command += ["-v"] return utils.system(command)
def get_public_key(): """ Return a valid string ssh public key for the user executing autoserv or autotest. If there's no DSA or RSA public key, create a DSA keypair with ssh-keygen and return it. :returns: a ssh public key :rtype: str """ ssh_conf_path = os.path.expanduser('~/.ssh') dsa_public_key_path = os.path.join(ssh_conf_path, 'id_dsa.pub') dsa_private_key_path = os.path.join(ssh_conf_path, 'id_dsa') rsa_public_key_path = os.path.join(ssh_conf_path, 'id_rsa.pub') rsa_private_key_path = os.path.join(ssh_conf_path, 'id_rsa') has_dsa_keypair = (os.path.isfile(dsa_public_key_path) and os.path.isfile(dsa_private_key_path)) has_rsa_keypair = (os.path.isfile(rsa_public_key_path) and os.path.isfile(rsa_private_key_path)) if has_dsa_keypair: logging.info('DSA keypair found, using it') public_key_path = dsa_public_key_path elif has_rsa_keypair: logging.info('RSA keypair found, using it') public_key_path = rsa_public_key_path else: logging.info('Neither RSA nor DSA keypair found, ' 'creating DSA ssh key pair') utils.system('ssh-keygen -t dsa -q -N "" -f %s' % dsa_private_key_path) public_key_path = dsa_public_key_path public_key = open(public_key_path, 'r') public_key_str = public_key.read() public_key.close() return public_key_str
def run_once(self): cpuType = utils.get_cpu_arch() logging.debug("cpu type is %s" % cpuType) # test return values result = utils.system("rootdev -s") logging.debug("Rootdev test res: %d", result) if (result != 0): raise error.TestFail("Rootdev failed") result = utils.system("rootdev -s -d") logging.debug("Rootdev test -d switch res: %d", result) if (result != 0): raise error.TestFail("Rootdev failed -s -d") # test with -d Results should be without the partition device number text = utils.system_output("rootdev -s -d 2>&1") text = text.strip() logging.debug("Rootdev -s -d txt is *%s*", text) self.test_no_partition(text, cpuType)
def importCert(cert, pwKey): pw = CraftChoicePrompt.promptForPassword( message= f"Enter the password for certificate: {Path(cert).name}", key=pwKey) return utils.system([ "security", "import", cert, "-k", self.loginKeychain, "-P", pw, "-T", "/usr/bin/codesign", "-T", "/usr/bin/productsign" ], stdout=subprocess.DEVNULL, secret=[password])
def check_hash(path, opti, arch, comp): cmd = "find {0} -type f -executable".format(path) cmd += ' -name "*{0}_{1}_{2}*" '.format(comp, arch, opti) cmd += "| sort | xargs md5sum" lines = system(cmd).splitlines() hashes = defaultdict(list) for line in lines: h, f = line.split() hashes[h].append(f) return hashes
def run_worker(cmd, cpu_cgroup, blkio_cgroup, pids_file): # main of new process for running an independent worker shell logging.debug('Worker running command: %s' % cmd) logging.debug('Moving to cpu_cgroup: %s' % cpu_cgroup.path) logging.debug('Moving to blkio_cgroup: %s' % blkio_cgroup.path) cpu_cgroup.move_my_task_here() blkio_cgroup.move_my_task_here() p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True) if pids_file: utils.system('echo %d >> %s' % (p.pid, pids_file)) logging.debug('running "%s" in container %s and io cgroup %s as pid %d', cmd, cpu_cgroup.path, blkio_cgroup.path, p.pid) p.wait() if pids_file: kill_slower_workers(p.pid, cpu_cgroup, pids_file) logging.debug(p.stdout.read())
def next(self, c, f, data): if data['setup'] == 'raid1': self.enamel.setup['disktype'] = 'raid' if data['setup'] == 'noraid': self.enamel.setup['disktype'] = 'single' def ret(*_): return url.root.child('DiskSelect') # Stop any existing raid devices (interferes with stuff) return utils.system('mdadm --stop --scan').addBoth(ret)
def roll(target_version): mojoms_gs_path = "gs://mojo/network/%s/mojoms.zip" % (target_version, ) network_service_path = os.path.join(mojo_root_dir, "mojo", "services", "network") mojoms_path = os.path.join(network_service_path, "public", "interfaces") version_path = os.path.join(network_service_path, "VERSION") with tempfile.NamedTemporaryFile() as temp_zip_file: gs.download_from_public_bucket(mojoms_gs_path, temp_zip_file.name) with zipfile.ZipFile(temp_zip_file.name) as z: z.extractall(mojoms_path) with open(version_path, 'w') as stamp_file: stamp_file.write(target_version) system(["git", "add", "public"], cwd=network_service_path) system(["git", "add", "VERSION"], cwd=network_service_path) chromium_rev = chromium_rev_number(target_version) commit("Roll the network service to https://crrev.com/" + chromium_rev, cwd=mojo_root_dir) return 0
def createPackage(self): """ create a package """ CraftCore.log.debug("packaging using the MacDMGPackager") defines = self.setDefaults(self.defines) if not "pkgproj" in defines: CraftCore.log.error( "Cannot not create .pkg because no .pkgproj was defined.") return False if not self.internalCreatePackage( defines, seperateSymbolFiles=True, packageSymbols=True): return False packageDest = Path(defines["setupname"]) if packageDest.exists(): utils.deleteFile(packageDest) pkgprojPath = defines["pkgproj"] # set output file basename packagesutil = CraftCore.cache.findApplication("packagesutil") if not utils.system([ packagesutil, '--file', pkgprojPath, 'set', 'project', 'name', packageDest.stem ]): return False packagesbuild = CraftCore.cache.findApplication("packagesbuild") if not utils.system([ packagesbuild, "-v", '--reference-folder', os.path.dirname(self.getMacAppPath(defines)), '--build-folder', packageDest.parent, pkgprojPath ]): return False if not CodeSign.signMacPackage(packageDest): return False CraftHash.createDigestFiles(packageDest) return True
def _test_udev_report_atmel(self): """Test that atmel trackpad failure can trigger udev crash report.""" DRIVER_DIR = '/sys/bus/i2c/drivers/atmel_mxt_ts' has_atmel_device = False if os.path.exists(DRIVER_DIR): for filename in os.listdir(DRIVER_DIR): if os.path.isdir(os.path.join(DRIVER_DIR, filename)): has_atmel_device = True if not has_atmel_device: logging.info('No atmel device, skip the test') return None self._set_consent(True) # Use udevadm to trigger a fake udev event representing atmel driver # failure. The uevent match rule in 99-crash-reporter.rules is # ACTION=="change", SUBSYSTEM=="i2c", DRIVER=="atmel_mxt_ts", # ENV{ERROR}=="1" RUN+="/sbin/crash_reporter # --udev=SUBSYSTEM=i2c-atmel_mxt_ts:ACTION=change" utils.system('udevadm control --property=ERROR=1', ignore_status=True) utils.system( 'udevadm trigger ' '--action=change ' '--subsystem-match=i2c ' '--attr-match=driver=atmel_mxt_ts', ignore_status=True) utils.system('udevadm control --property=ERROR=0', ignore_status=True) utils.poll_for_condition( self.CheckAtmelCrashes, timeout=60, exception=error.TestFail('No valid Atmel crash reports'))
def exec_stop(self): fwmark = config.global_config["transproxy"]["fwmark"] ip_route_table = config.global_config["transproxy"]["ip_route_table"] self.iptables.del_all() utils.system("ip route del local default dev lo table %s" % ip_route_table) utils.system("ip rule del fwmark %s lookup %s" % (fwmark, ip_route_table)) self.stopped = True if not self.process: utils.log( "Not killing ss-redir process, since self.process is None") elif type(self.process.returncode) != int: utils.log("Killing ss-redir process") self.kill() else: utils.log( "Not killing ss-redir process, since self.process.returncode is int" )
def updateSharedMimeInfo(package) -> bool: if OsUtils.isWin(): dataDir = os.path.join("bin", "data", "mime") else: dataDir = os.path.join("share", "mime") # only check in imageDir, if installDir differs from imageDir it is irrelevant for us if not os.path.isdir(os.path.join(package.imageDir(), dataDir)): return True dataDir = os.path.join(CraftCore.standardDirs.craftRoot(), dataDir) flags = [] if CraftCore.debug.verbose() > 0: flags += ["-V"] return utils.system(["update-mime-database"] + flags + [dataDir])
def form_singleConfig(self, data): def gotDisks(disks): print "HERE" print disks f = form.Form() myDisks = {} # Split on new lines, and remove the * that signifies bootable partitions for n in disks.replace('*','').split('\n'): if not n.strip(): continue parts = n.split() device = parts[0].strip('/dev/') cyls = int(parts[3].strip('-').strip('+')) myDisks[device] = cyls self.disks = [] cnt = 0 for dev, cyls in myDisks.items(): cnt += 1 size = (int(cyls) * 8225280)/(1024*1024) self.disks.append(dev) f.addField(dev, form.String(), form.widgetFactory(form.SelectChoice, options=( ('/', '/'), ('/var', '/var'), ('/storage', '/storage') ) ), label = [tags.strong[dev], " (%sMB)" % size] ) if cnt == 1: f.data[dev] = '/' if cnt ==2: f.data[dev] = '/var' if cnt ==3: f.data[dev] = '/storage' # If more than one drive exists.. f.addAction(self.nextSingle) return f return utils.system('sfdisk -R -l 2>&1| grep "^/dev/" | grep "Linux$"').addBoth(gotDisks)
def execute(self, path, cmd, args="", **kwargs): # try to locate the command tmp = CraftCore.cache.findApplication(cmd) if tmp: cmd = tmp if CraftCore.compiler.isWindows: command = f"{self._findBash()} -c \"{self.toNativePath(cmd)} {args}\"" else: command = f"{self.toNativePath(cmd)} {args}" env = dict(os.environ) env.update(self.environment) env.update(kwargs.get("env", {})) return utils.system(command, cwd=path, env=env, **kwargs)
def patch(dest_dir, relative_patches_dir=os.curdir): """Applies the *.patch files in |relative_patches_dir|. Args: relative_patches_dir: A directory path relative to the current directory. Defaults to the directory of this file. Raises: subprocess.CalledProcessError if the patch couldn't be applied. """ patches_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), relative_patches_dir) assert os.path.isdir(patches_dir) os.chdir(dest_dir) for p in utils.find(["*.patch"], patches_dir): print "applying patch %s" % os.path.basename(p) try: utils.system(["git", "apply", p]) utils.commit("applied patch %s" % os.path.basename(p)) except subprocess.CalledProcessError: print "ERROR: patch %s failed to apply" % os.path.basename(p) raise
def run_once(self): errors = 0 test_dir = '/tmp/chromium_lsm_test_dir' os.mkdir(test_dir, 0700) mnt_target = '%s/mount_point' % (test_dir) os.mkdir(mnt_target, 0700) sym_target = '%s/symlink' % (test_dir) os.symlink('mount_point', sym_target) # Mounting should succeed (no symbolic link in mount path). errors += self._check_mount(mnt_target, True, 'Unable to mount on a directory') # Mounting should fail as we used a mount path with a symbolic link. errors += self._check_mount(sym_target, False, 'Unexpectedly mounted on a symlink') utils.system('rm -rf ' + test_dir) # If self.error is not zero, there were errors. if errors > 0: raise error.TestFail('Failed %d tests' % errors)
def system(cmdline, result='output'): """Run a command and return its output. If result == 'status', the exit status of the command is returned. If result == 'output', the output of the command is returned. If result == 'both', a tuple of status and output is returned. """ sta, out, err = utils.system(cmdline) if result == 'status': return sta elif result == 'output': return out elif result == 'both': return sta, out
def signMacPackage(packagePath: str): if not CraftCore.settings.getboolean("CodeSigning", "Enabled", False): return True # special case, two independent setups of craft might want to sign at the same time and only one keychain can be unlocked at a time with _MacSignScope() as scope: packagePath = Path(packagePath) devID = CraftCore.settings.get("CodeSigning", "MacDeveloperId") if packagePath.name.endswith(".dmg"): # sign dmg if not utils.system([ "codesign", "--force", "--keychain", scope.loginKeychain, "--sign", f"Developer ID Application: {devID}", packagePath ]): return False # TODO: this step would require notarisation # verify dmg signature utils.system([ "spctl", "-a", "-t", "open", "--context", "context:primary-signature", packagePath ]) else: # sign pkg packagePathTmp = f"{packagePath}.sign" if not utils.system([ "productsign", "--keychain", scope.loginKeychain, "--sign", f"Developer ID Installer: {devID}", packagePath, packagePathTmp ]): return False utils.moveFile(packagePathTmp, packagePath) return True
def system(self, command, errorMessage="", debuglevel=1, **kw): """convencience function for running system commands. This method prints a debug message and then runs a system command. If the system command returns with errors the method prints an error message and exits if @ref self.subinfo.options.exitOnErrors is true""" if utils.system(command, **kw): return True if self.subinfo.options.exitOnErrors: EmergeDebug.warning("while running %s cmd: %s" % (errorMessage, str(command))) else: EmergeDebug.warning("while running %s cmd: %s" % (errorMessage, str(command))) return False
def execute(self, path, cmd, args="", **kwargs): # try to locate the command if CraftCore.compiler.isWindows: tmp = CraftCore.cache.findApplication(cmd) if tmp: cmd = tmp command = Arguments([ self._findBash(), "-c", str(Arguments([self.toNativePath(cmd), args])) ]) else: command = Arguments([cmd, args]) env = dict(os.environ) env.update(self.environment) env.update(kwargs.get("env", {})) return utils.system(command, cwd=path, env=env, **kwargs)
def signWindows(fileNames: [str]) -> bool: if not CraftCore.settings.getboolean("CodeSigning", "Enabled", False): return True if not CraftCore.compiler.isWindows: CraftCore.log.warning( "Code signing is currently only supported on Windows") return True signTool = CraftCore.cache.findApplication("signtool", forceCache=True) if not signTool: env = SetupHelper.getMSVCEnv() signTool = CraftCore.cache.findApplication("signtool", env["PATH"], forceCache=True) if not signTool: CraftCore.log.warning( "Code signing requires a VisualStudio installation") return False command = [ signTool, "sign", "/tr", "http://timestamp.digicert.com", "/td", "SHA256", "/fd", "SHA256", "/a" ] certFile = CraftCore.settings.get("CodeSigning", "Certificate", "") subjectName = CraftCore.settings.get("CodeSigning", "CommonName", "") certProtected = CraftCore.settings.getboolean("CodeSigning", "Protected", False) kwargs = dict() if certFile: command += ["/f", certFile] if subjectName: command += ["/n", subjectName] if certProtected: password = CraftChoicePrompt.promptForPassword( message='Enter the password for your package signing certificate', key="WINDOWS_CODE_SIGN_CERTIFICATE_PASSWORD") command += ["/p", password] kwargs["secret"] = [password] if True or CraftCore.debug.verbose() > 0: command += ["/v"] else: command += ["/q"] for args in utils.limitCommandLineLength(command, fileNames): if not utils.system(args, **kwargs): return False return True
def _createShortPath(longPath) -> str: if not CraftShortPath._useShortpaths: return longPath import utils utils.createDir(CraftCore.standardDirs.junctionsDir()) longPath = OsUtils.toNativePath(longPath) path = CraftCore.standardDirs.junctionsDir() / hex( zlib.crc32(bytes(longPath, "UTF-8")))[2:] delta = len(longPath) - len(str(path)) if delta <= 0: CraftCore.debug.log.debug( f"Using junctions for {longPath} wouldn't save characters returning original path" ) CraftCore.debug.log.debug(f"{longPath}\n" f"{path}, gain: {delta}") return longPath utils.createDir(longPath) if not os.path.isdir(path): if OsUtils.isUnix(): ok = utils.createSymlink(longPath, path, useAbsolutePath=True, targetIsDirectory=True) else: # note: mklink is a CMD command => needs shell ok = utils.system(["mklink", "/J", path, longPath], shell=True, stdout=subprocess.DEVNULL, logCommand=False) if not ok: CraftCore.debug.log.critical( f"Could not create shortpath {path}, for {longPath}") return longPath else: if not os.path.samefile(path, longPath): CraftCore.debug.log.critical( f"Existing short path {path}, did not match {longPath}") return longPath CraftCore.debug.log.debug(f"Mapped \n" f"{longPath} to\n" f"{path}, gained {delta}") return path
def __signMacApp(appPath : Path, scope : _MacSignScope): CraftCore.log.info(f"Sign {appPath}") devID = CraftCore.settings.get("CodeSigning", "MacDeveloperId") bundlePattern = re.compile(r".*(\.app|\.framework)$", re.IGNORECASE) # get all bundles, as we specify handleAppBundleAsFile we will not yet get nested bundles for bun in utils.filterDirectoryContent(appPath, whitelist=lambda x, root: bundlePattern.match(x.path), blacklist=lambda x, root: True, handleAppBundleAsFile = True): if not __signMacApp(Path(bun), scope): return False # all files in the bundle bundeFilter = lambda x, root: not Path(x.path).is_symlink() and not bundlePattern.match(x.path) filter = bundeFilter # we can only sign non binary files in Resources, else they get stored in the # extended attributes and might get lost during deployment # TODO: allow for dmg? # https://github.com/packagesdev/packages/issues/65 if "Contents/Resources" not in str(appPath): filter = lambda x, root: bundeFilter(x, root) and utils.isBinary(x.path) binaries = list(utils.filterDirectoryContent(appPath, whitelist=lambda x, root: filter(x, root), blacklist=lambda x, root: True, handleAppBundleAsFile = True)) mainApp = appPath / "Contents/MacOS" / appPath.name.split(".")[0] if str(mainApp) in binaries: binaries.remove(str(mainApp)) signCommand = ["codesign", "--keychain", scope.loginKeychain, "--sign", f"Developer ID Application: {devID}", "--force", "--preserve-metadata=identifier,entitlements", "--options", "runtime", "--verbose=99", "--timestamp"] for command in utils.limitCommandLineLength(signCommand, binaries): if not utils.system(command): return False if not utils.system(signCommand + ["--deep", appPath]): return False ## Verify signature if not utils.system(["codesign", "--display", "--verbose", appPath]): return False if not utils.system(["codesign", "--verify", "--verbose", "--strict", "--deep", appPath]): return False # TODO: this step might require notarisation utils.system(["spctl", "-a", "-t", "exec", "-vv", appPath]) return True
def createPackage(self): """ create a package """ CraftCore.log.debug("packaging using the MacDMGPackager") defines = self.setDefaults(self.defines) # TODO: provide an image with dbg files if not self.internalCreatePackage(defines): return False appPath = self.getMacAppPath(defines) archive = os.path.normpath(self.archiveDir()) CraftCore.log.info(f"Packaging {appPath}") dmgDest = defines["setupname"] if os.path.exists(dmgDest): utils.deleteFile(dmgDest) appName = defines['appname'] + ".app" if not utils.system([ "create-dmg", "--volname", os.path.basename(dmgDest), # Add a drop link to /Applications: "--icon", appName, "140", "150", "--app-drop-link", "350", "150", dmgDest, appPath ]): return False if not CodeSign.signMacPackage(dmgDest): return False CraftHash.createDigestFiles(dmgDest) return True
def exec_stop(self): self.stopped = True if self.started: fwmark = config.global_config["transproxy"]["fwmark"] ip_route_table = config.global_config["transproxy"][ "ip_route_table"] interface_name = config.global_config["transproxy"]["wireguard"][ "interface_name"] self.iptables.del_all() utils.system("ip route del table %d default dev %s" % (ip_route_table, interface_name)) utils.system("ip rule del fwmark %d table %d" % (fwmark, ip_route_table)) utils.system("ip link delete %s" % interface_name)
def _createShortPath(longPath) -> str: import utils longPath = OsUtils.toNativePath(longPath) if not CraftShortPath._useShortpaths: return longPath if not os.path.isdir(CraftCore.standardDirs.junctionsDir()): os.makedirs(CraftCore.standardDirs.junctionsDir()) path = OsUtils.toNativePath(os.path.join(CraftCore.standardDirs.junctionsDir(), hex(zlib.crc32(bytes(longPath, "UTF-8")))[2:])) if len(longPath) < len(path): CraftCore.debug.log.debug(f"Using junctions for {longPath} wouldn't save characters returning original path") CraftCore.debug.log.debug(f"{longPath}\n" f"{path}, gain:{len(longPath) - len(path)}") return longPath os.makedirs(longPath, exist_ok=True) if not os.path.isdir(path): # note: mklink is a CMD command => needs shell if not utils.system(["mklink", "/J", path, longPath], shell=True, stdout=subprocess.DEVNULL, logCommand=False): CraftCore.debug.log.critical(f"Could not create shortpath {path}, for {longPath}") return longPath else: if not os.path.samefile(path, longPath): CraftCore.debug.log.critical(f"Existing short path {path}, did not match {longPath}") return longPath return path
def _createShortPath(longPath) -> str: if not os.path.isdir(CraftStandardDirs.junctionsDir()): os.makedirs(CraftStandardDirs.junctionsDir()) path = os.path.join(CraftStandardDirs.junctionsDir(), str(zlib.crc32(bytes(longPath, "UTF-8")))) if len(longPath) < len(path): craftDebug.log.info( f"Using junctions for {longPath} wouldn't save characters returning original path" ) return longPath if not os.path.isdir(path): if not os.path.isdir(longPath): os.makedirs(longPath) # note: mklink is a CMD command => needs shell if not utils.system(["mklink", "/J", path, longPath], shell=True): craftDebug.log.critical( f"Could not create shortpath {path}, for {longPath}") return longPath else: if not os.path.samefile(path, longPath): craftDebug.log.critical( f"Existing short path {path}, did not match {longPath}") return longPath return path
def roll(target_version): try: chromium_rev = chromium_rev_number(target_version) except urllib2.HTTPError: print ("Failed to identify a Chromium revision associated with %s. " "Ensure that target_version is a Chromium origin/master " "commit.") % (target_version) return 1 mojoms_gs_path = "gs://mojo/network_service/%s/mojoms.zip" % (target_version,) network_service_path = os.path.join( mojo_root_dir, "mojo", "services", "network") mojoms_path = os.path.join(network_service_path, "public", "interfaces") version_path = os.path.join(network_service_path, "VERSION") try: with tempfile.NamedTemporaryFile() as temp_zip_file: gs.download_from_public_bucket(mojoms_gs_path, temp_zip_file.name) try: system(["git", "rm", "-r", mojoms_path], cwd=mojo_root_dir) except subprocess.CalledProcessError: print ("Could not remove %s. " "Ensure your local tree is in a clean state." % mojoms_path) return 1 with zipfile.ZipFile(temp_zip_file.name) as z: z.extractall(mojoms_path) # pylint: disable=C0302,bare-except except: print ("Failed to download the mojom files associated with %s. Ensure that " "the corresponding network service artifacts were uploaded to " "Google Storage.") % (target_version) return 1 with open(version_path, 'w') as stamp_file: stamp_file.write(target_version) system(["git", "add", "public"], cwd=network_service_path) system(["git", "add", "VERSION"], cwd=network_service_path) commit("Roll the network service to https://crrev.com/" + chromium_rev, cwd=mojo_root_dir) return 0
import matplotlib.pyplot as plt from ftocp import FTOCP from nlp import NLP from matplotlib import rc from numpy import linalg as la # rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']}) # rc('text', usetex=True) # Aaron added import pdb # ============================= # Initialize system parameters x0 = np.zeros(4) dt = 0.1 # Discretization time sys = system(x0, dt) # initialize system object maxTime = 14 # Simulation time goal = np.array([10,10,0,np.pi/2]) # Initialize mpc parameters N = 20; n = 4; d = 2; Q = 1*np.eye(n) R = 1*np.eye(d) Qf = 1000*np.eye(n) # ================================================================= # ======================== Subsection: Nonlinear MPC ============== # First solve the nonlinear optimal control problem as a Non-Linear Program (NLP) printLevel = 1 xub = np.array([15, 15, 15, 15]) uub = np.array([10, 0.5])
def environment(self): if not self._environment: mergeroot = self.toNativePath(CraftCore.standardDirs.craftRoot()) ldflags = f" -L{mergeroot}/lib " cflags = f" -I{mergeroot}/include " if CraftCore.compiler.isMacOS: # Only look for includes/libraries in the XCode SDK on MacOS to avoid errors with # libraries installed by homebrew (causes errors e.g. with iconv since headers will be # found in /usr/local/include first but libraries are searched for in /usr/lib before # /usr/local/lib. See https://langui.sh/2015/07/24/osx-clang-include-lib-search-paths/ # Ensure that /usr/include comes before /usr/local/include in the header search path to avoid # pulling in headers from /usr/local/include (e.g. installed by homebrew) that will cause # linker errors later. sdkPath = CraftCore.cache.getCommandOutput( "xcrun", "--show-sdk-path")[1].strip() deploymentFlag = f"-mmacosx-version-min={os.environ['MACOSX_DEPLOYMENT_TARGET']}" cflags = f" -isysroot {sdkPath} {deploymentFlag} {cflags} -isystem /usr/include" ldflags = f" -isysroot {sdkPath} {deploymentFlag} {ldflags}" # TODO: well that sounded like a good idea, but is broken with recent xcode # when fixed we probably should also set that flag for the rest too? # See https://github.com/Homebrew/homebrew-core/issues/2674 for the -no_weak_imports flag #ldflags = f" -Wl,-no_weak_imports {ldflags}" if CraftCore.compiler.isMSVC(): # based on Windows-MSVC.cmake if self.buildType == "Release": cflags += " -MD -O2 -Ob2 -DNDEBUG " elif self.buildType == "RelWithDebInfo": cflags += " -MD -Zi -O2 -Ob1 -DNDEBUG " ldflags += " -debug " elif self.buildType == "Debug": cflags += " -MDd -Zi -Ob0 -Od " ldflags += " -debug -pdbtype:sept " else: if self.buildType == "Release": cflags += " -O3 -DNDEBUG " if self.buildType == "RelWithDebInfo": cflags += " -O2 -g -DNDEBUG " elif self.buildType == "Debug": cflags += " -O0 -g3 " if OsUtils.isWin(): def convertPath(path: str): return ":".join([ str(self.toNativePath(p)) for p in path.split(os.path.pathsep) ]) path = "/usr/local/bin:/usr/bin:/bin:/usr/bin/site_perl:/usr/bin/vendor_perl:/usr/bin/core_perl" if CraftCore.compiler.isMinGW(): gcc = shutil.which("gcc") if gcc: path = f"{self.toNativePath(os.path.dirname(gcc))}:{path}" elif CraftCore.compiler.isMSVC(): path = f"{self.toNativePath(os.path.dirname(shutil.which('cl')))}:{path}" self._environment[ "PATH"] = f"{path}:{convertPath(os.environ['PATH'])}" self._environment["PKG_CONFIG_PATH"] = convertPath( os.environ["PKG_CONFIG_PATH"]) if "make" in self._environment: del self._environment["make"] # MSYSTEM is used by uname if CraftCore.compiler.isMinGW(): self._environment[ "MSYSTEM"] = f"MINGW{CraftCore.compiler.bits}_CRAFT" elif CraftCore.compiler.isMSVC(): self._environment[ "MSYSTEM"] = f"MSYS{CraftCore.compiler.bits}_CRAFT" if self.useMSVCCompatEnv and CraftCore.compiler.isMSVC(): automake = [] for d in os.scandir( os.path.join(os.path.dirname(self._findBash()), "..", "share")): if d.name.startswith("automake"): automake += [(d.name.rsplit("-")[1], os.path.realpath(d.path))] automake.sort(key=lambda x: CraftVersion(x[0])) latestAutomake = automake[-1][1] if False: cl = "clang-cl" else: cl = "cl" clWrapper = self.toNativePath( os.path.join(latestAutomake, "compile")) self._environment[ "AR"] = f"{self.toNativePath(os.path.join(latestAutomake, 'ar-lib'))} lib" self._environment["LD"] = "link -nologo" self._environment["CC"] = f"{clWrapper} {cl} -nologo" self._environment["CXX"] = self._environment["CC"] self._environment["CPP"] = f"{cl} -nologo -EP" self._environment["CXXCPP"] = self._environment["CPP"] self._environment["NM"] = "dumpbin -symbols" self._environment[ "RC"] = f"windres -O COFF --target={'pe-i386' if CraftCore.compiler.isX86() else 'pe-x86-64'} --preprocessor='cl -nologo -EP -DRC_INVOKED -DWINAPI_FAMILY=0'" self._environment["STRIP"] = ":" self._environment["RANLIB"] = ":" self._environment["F77"] = "no" self._environment["FC"] = "no" cflags += ( " -GR -W3 -EHsc" # dynamic and exceptions enabled " -D_USE_MATH_DEFINES -DWIN32_LEAN_AND_MEAN -DNOMINMAX -D_CRT_SECURE_NO_WARNINGS" " -wd4005" # don't warn on redefine " -wd4996" # The POSIX name for this item is deprecated. ) if CraftCore.compiler.getMsvcPlatformToolset() > 120: cflags += " -FS" if CraftCore.compiler.isAndroid: toolchainPath = os.path.join( CraftCore.standardDirs.tmpDir(), f"android-{CraftCore.compiler.architecture}-toolchain") utils.system([ "python3", os.path.join(os.environ.get("ANDROID_NDK_ROOT"), "build/tools/make_standalone_toolchain.py"), "--install-dir", toolchainPath, "--arch", CraftCore.compiler.architecture, "--api", CraftCore.compiler.androidApiLevel() ]) self._environment["PATH"] = os.path.join( toolchainPath, "bin") + ":" + os.environ["PATH"] self._environment["AR"] = "ar" self._environment["AS"] = "clang" self._environment["CC"] = "clang" self._environment["CXX"] = "clang++" self._environment["LD"] = "ld" self._environment["STRIP"] = "strip" self._environment["RANLIB"] = "ranlib" self._environment["CFLAGS"] = os.environ.get("CFLAGS", "").replace( "$", "$$") + cflags self._environment["CXXFLAGS"] = os.environ.get( "CXXFLAGS", "").replace("$", "$$") + cflags self._environment["LDFLAGS"] = os.environ.get( "LDFLAGS", "").replace("$", "$$") + ldflags return self._environment