def _loadRecipe(helper, package, recipePath): # Load the recipe use.setBuildFlagsFromFlavor(package.getPackageName(), helper.cfg.buildFlavor, error=False) if package.targetConfig.factory and package.targetConfig.factory != 'factory': sourceTrove, targetDir = tempSourceTrove(recipePath, package, helper) loader = RecipeLoaderFromSourceDirectory(sourceTrove, repos=helper.getRepos(), cfg=helper.cfg, parentDir=targetDir, labelPath=helper.plan.installLabelPath ) else: sourceTrove = None loader = RecipeLoader(recipePath, helper.cfg, helper.getRepos(), directory=helper.plan.recipeDir, factory=package.targetConfig.factory, ) recipeClass = loader.getRecipe() dummybranch = Branch([helper.plan.getTargetLabel()]) dummyrev = Revision('1-1') dummyver = dummybranch.createVersion(dummyrev) macros = { 'buildlabel': dummybranch.label().asString(), 'buildbranch': dummybranch.asString(), } # Instantiate and setup if needed lcache = RepositoryCache(helper.getRepos(), refreshFilter=lambda x: helper.plan.refreshSources) if recipeClass.getType() == cny_recipe.RECIPE_TYPE_GROUP: recipeObj = recipeClass( repos=helper.getRepos(), cfg=helper.cfg, label=dummybranch.label(), flavor=helper.cfg.buildFlavor, laReposCache=lcache, extraMacros=macros, ) elif recipeClass.getType() in [ cny_recipe.RECIPE_TYPE_PACKAGE, cny_recipe.RECIPE_TYPE_INFO, cny_recipe.RECIPE_TYPE_CAPSULE, ]: recipeObj = recipeClass( cfg=helper.cfg, laReposCache=lcache, srcdirs=[], extraMacros=macros, lightInstance=True, ) else: return recipeClass if not recipeObj.needsCrossFlags(): recipeObj.crossRequires = [] if sourceTrove is None: recipeObj.populateLcache() recipeObj.sourceVersion = dummyver recipeObj.loadPolicy() recipeObj.setup() return recipeObj
def testMacroOverrides(self): self.overrideBuildFlavor('is:x86(!i686,!i586,i486)') use.setBuildFlagsFromFlavor('group-test', self.cfg.buildFlavor) recipeClass = self._loadRecipe() dummy = recipeClass(None, self.cfg, None, None, None, lightInstance=True) self.assertEqual(dummy.macros.dummyMacro, 'right')
def testTargetFlavor(self): use.setBuildFlagsFromFlavor(None, self.cfg.buildFlavor, error=False) targetFlavor = str( use.createFlavor(None, use.Arch._iterAll(), targetDep=True)) assert (targetFlavor) flavor = str( use.createFlavor(None, use.Arch._iterAll(), targetDep=False)) assert (targetFlavor.replace('target', 'is') == flavor)
def _setArchFlags(flavor): # given an flavor, make use.Arch match that flavor. for flag in use.Arch._iterAll(): flag._set(False) use.setBuildFlagsFromFlavor(self.name, flavor, error=False, useCross=False)
def runCommand(self, thisCommand, cfg, argSet, args, debugAll=False): client = conaryclient.ConaryClient(cfg) repos = client.getRepos() callback = commit.CheckinCallback(cfg) if not cfg.buildLabel and cfg.installLabelPath: cfg.buildLabel = cfg.installLabelPath[0] sys.excepthook = util.genExcepthook(debug=cfg.debugExceptions, debugCtrlC=debugAll) if cfg.installLabelPath: cfg.installLabel = cfg.installLabelPath[0] else: cfg.installLabel = None cfg.initializeFlavors() log.setMinVerbosity(log.INFO) log.resetErrorOccurred() # set the build flavor here, just to set architecture information # which is used when initializing a recipe class use.setBuildFlagsFromFlavor(None, cfg.buildFlavor, error=False) profile = False if argSet.has_key('lsprof'): import cProfile prof = cProfile.Profile() prof.enable() profile = 'lsprof' del argSet['lsprof'] keyCache = openpgpkey.getKeyCache() keyCache.setPublicPath(cfg.pubRing) repos = conaryclient.ConaryClient(cfg).getRepos() keyCacheCallback = openpgpkey.KeyCacheCallback(repos, cfg) keyCache.setCallback(keyCacheCallback) try: rv = options.MainHandler.runCommand(self, thisCommand, cfg, argSet, args, callback=callback, repos=client.getRepos(), profile=profile) finally: if profile == 'lsprof': prof.disable() prof.dump_stats('cvc.lsprof') prof.print_stats() elif profile: prof.stop() if log.errorOccurred(): sys.exit(2) return rv
def getSysRootPath(flavor): # FIXME: if we wanted to get this exactly right, we'd have to load the # macros from /etc/macros and use those values for sysroot. # Best would be to do that at the same time as we load the recipe itself # and store it w/ the trove, because otherwise it's misleading. if hasTarget(flavor): flavor = getSysRootFlavor(flavor) use.setBuildFlagsFromFlavor(None, flavor, error=False) target = '%s-unknown-linux' % use.Arch._getMacro('targetarch') return '/opt/cross-target-%s/sys-root' % target
def refresh(self, targetDir=None): """ Refresh the checked-out sources for a conary source package. @param targetDir: checkout directory to refresh @type targetDir: string """ cfg = self.getConaryConfig() self._initializeFlavors() use.setBuildFlagsFromFlavor(None, cfg.buildFlavor, False) return checkin.refresh(self._getRepositoryClient(), cfg, dirName=targetDir)
def commit(self, targetDir, message): cfg = self.getConaryConfig() self._initializeFlavors() use.setBuildFlagsFromFlavor(None, cfg.buildFlavor, False) cwd = os.getcwd() try: os.chdir(targetDir) checkin.commit(self._getRepositoryClient(), cfg, message=message) except conaryerrors.CvcError, e: tb = sys.exc_info()[2] raise errors.RbuildError, str(e), tb
def testMacroOverrides(self): self.addTestPkg(1) repos = self.openRepository() loader = loadrecipe.recipeLoaderFromSourceComponent('test1:source', self.cfg, repos)[0] recipeClass = loader.getRecipe() self.overrideBuildFlavor('is:x86(!i686,!i586,i486)') use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) dummy = recipeClass(self.cfg, None, None, {}) assert(dummy.macros.dummyMacro == 'right')
def loadRecipeClass( repos, name, version, flavor, trv=None, ignoreInstalled=True, root=None, loadInstalledSource=None, overrides=None, buildLabel=None, cfg=None, ): if trv is None: trv = repos.getTrove(name, version, deps.parseFlavor(""), withFiles=True) if cfg is None: cfg = conarycfg.ConaryConfiguration(False) else: cfg = copy.deepcopy(cfg) cfg.initializeFlavors() if root: cfg.root = root branch = version.branch() label = version.branch().label() cfg.buildLabel = label cfg.buildFlavor = flavor name = name.split(":")[0] use.LocalFlags._clear() use.setBuildFlagsFromFlavor(name, flavor, error=False) use.resetUsed() use.track(True) loader = RecipeLoaderFromSourceTrove( trv, repos, cfg, name + ":source", branch, ignoreInstalled=ignoreInstalled, db=loadInstalledSource, overrides=overrides, buildFlavor=flavor, ) recipeClass = loader.getRecipe() recipeClass._trove = trv use.track(False) localFlags = flavorutil.getLocalFlags() usedFlags = use.getUsed() use.LocalFlags._clear() return loader, recipeClass, localFlags, usedFlags
def loadRecipeClass(repos, name, version, flavor, trv=None, ignoreInstalled=True, root=None, loadInstalledSource=None, overrides=None, buildLabel=None, cfg=None): if trv is None: trv = repos.getTrove(name, version, deps.parseFlavor(''), withFiles=True) if cfg is None: cfg = conarycfg.ConaryConfiguration(False) else: cfg = copy.deepcopy(cfg) cfg.initializeFlavors() if root: cfg.root = root branch = version.branch() label = version.branch().label() cfg.buildLabel = label cfg.buildFlavor = flavor name = name.split(':')[0] use.LocalFlags._clear() use.setBuildFlagsFromFlavor(name, flavor, error=False) use.resetUsed() use.track(True) loader = RecipeLoaderFromSourceTrove(trv, repos, cfg, name + ':source', branch, ignoreInstalled=ignoreInstalled, db=loadInstalledSource, overrides=overrides, buildFlavor=flavor) recipeClass = loader.getRecipe() recipeClass._trove = trv use.track(False) localFlags = flavorutil.getLocalFlags() usedFlags = use.getUsed() use.LocalFlags._clear() return loader, recipeClass, localFlags, usedFlags
def testPackageFlags(self): assert(not use.PackageFlags.kernel.pae) self.assertRaises(RuntimeError, setattr, use.PackageFlags.kernel, 'pae', True) self.assertRaises(RuntimeError, setattr, use.PackageFlags, 'foo', True) self.assertRaises(RuntimeError, bool, use.PackageFlags) assert(not use.PackageFlags.kernel.pae) use.setBuildFlagsFromFlavor(None, parseFlavor('kernel.pae'), error=False) assert(bool(use.PackageFlags.kernel.pae)) use.clearFlags() use.setBuildFlagsFromFlavor(None, parseFlavor('!kernel.pae'), error=False) assert(not bool(use.PackageFlags.kernel.pae)) assert(str(use.PackageFlags.kernel.pae) == 'PackageFlags.kernel.pae: False')
def writeControl(self): pkgName = self._getPkgName() log.info('writing control file for %s' % pkgName) recipeDir = self._helper._checkout(pkgName) control = self.getControl() if not control and os.path.exists(os.path.join(recipeDir, 'control')): self._helper._removeFile(recipeDir, 'control') if control: fd = open(os.path.join(recipeDir, 'control'), 'w') fd.write(control) fd.close() self._helper._addFile(recipeDir, 'control') use.setBuildFlagsFromFlavor(pkgName, self._helper._ccfg.buildFlavor, error=False) self._helper._commit(recipeDir, 'add/update control file')
def testPackageFlags(self): assert (not use.PackageFlags.kernel.pae) self.assertRaises(RuntimeError, setattr, use.PackageFlags.kernel, 'pae', True) self.assertRaises(RuntimeError, setattr, use.PackageFlags, 'foo', True) self.assertRaises(RuntimeError, bool, use.PackageFlags) assert (not use.PackageFlags.kernel.pae) use.setBuildFlagsFromFlavor(None, parseFlavor('kernel.pae'), error=False) assert (bool(use.PackageFlags.kernel.pae)) use.clearFlags() use.setBuildFlagsFromFlavor(None, parseFlavor('!kernel.pae'), error=False) assert (not bool(use.PackageFlags.kernel.pae)) assert (str( use.PackageFlags.kernel.pae) == 'PackageFlags.kernel.pae: False')
def testBasicMacros(self): oldPath = os.environ['PATH'] try: self.addTestPkg(1) repos = self.openRepository() loader = loadrecipe.recipeLoaderFromSourceComponent('test1:source', self.cfg, repos)[0] recipeClass = loader.getRecipe() use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) # This should override the value from extraMacros self.cfg.configLine('macros thing value') # And this should override the default value self.cfg.configLine('macros bindir /binaries') recipeObj = recipeClass(self.cfg, None, None, extraMacros={'thing': 'wrong'}) self.assertEqual(recipeObj.macros.name, 'test1') self.assertEqual(recipeObj.macros.version, '1.0') self.assertEqual(recipeObj.macros.bindir, '/binaries') finally: os.environ['PATH'] = oldPath
def testCrossCompileSetupMacrosOverride(self): macroOverrides = {'crossdir' : 'foo'} oldPath = os.environ['PATH'] try: self.addTestPkg(1) repos = self.openRepository() loader = loadrecipe.recipeLoaderFromSourceComponent('test1:source', self.cfg, repos)[0] recipeClass = loader.getRecipe() self.overrideBuildFlavor('is:x86(!i686,!i586,i486)') use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) # cross compiling something for x86_64 cross1 = recipeClass(self.cfg, None, None, macroOverrides, (None, 'x86_64', False)) assert(cross1.macros.target == 'x86_64-unknown-linux') assert(cross1.macros.host == 'x86_64-unknown-linux') assert(cross1.macros.build == 'i486-unknown-linux') assert(use.Arch.x86_64) assert(cross1.macros.crossprefix == '/opt/foo') finally: os.environ['PATH'] = oldPath
def testSetBuildFlagsFromFlavor(self): Flavor = deps.parseFlavor use.setBuildFlagsFromFlavor(None, Flavor('is: ppc')) assert(use.Arch.ppc) self.assertRaises(RuntimeError, use.setBuildFlagsFromFlavor, None, Flavor('is: x86 ppc')) use.setBuildFlagsFromFlavor(None, Flavor('is: x86')) assert(use.Arch.x86) assert(not use.Arch.ppc) self.assertRaises(RuntimeError, use.setBuildFlagsFromFlavor, None, Flavor('is: ppc x86_64')) self.assertRaises(AttributeError, use.setBuildFlagsFromFlavor, None, 'fjdkf') self.logFilter.add() use.setBuildFlagsFromFlavor(None, Flavor('fjdkf,!ssl'), error=False, warn=True) self.logFilter.compare('warning: ignoring unknown Use flag fjdkf') assert(not use.Use.ssl) use.setBuildFlagsFromFlavor(None, Flavor('ssl'), error=False)
def testSetBuildFlagsFromFlavor(self): Flavor = deps.parseFlavor use.setBuildFlagsFromFlavor(None, Flavor('is: ppc')) assert (use.Arch.ppc) self.assertRaises(RuntimeError, use.setBuildFlagsFromFlavor, None, Flavor('is: x86 ppc')) use.setBuildFlagsFromFlavor(None, Flavor('is: x86')) assert (use.Arch.x86) assert (not use.Arch.ppc) self.assertRaises(RuntimeError, use.setBuildFlagsFromFlavor, None, Flavor('is: ppc x86_64')) self.assertRaises(AttributeError, use.setBuildFlagsFromFlavor, None, 'fjdkf') self.logFilter.add() use.setBuildFlagsFromFlavor(None, Flavor('fjdkf,!ssl'), error=False, warn=True) self.logFilter.compare('warning: ignoring unknown Use flag fjdkf') assert (not use.Use.ssl) use.setBuildFlagsFromFlavor(None, Flavor('ssl'), error=False)
def testMultilib(self): depSet = deps.DependencySet() depSet.addDeps(deps.InstructionSetDependency, arch.flags_x86_64()[0]) use.setBuildFlagsFromFlavor(None, depSet) self.assertTrue(use.Arch.x86_64) self.assertFalse(use.Arch.x86)
try: # get the correct environment variables from this root # some packages depend on environment variables e.g. $QTDIR that # are set by other packages. setupEnvironment() # now override flags set in flavor # don't need to reset this flavor ever, because # we are in a fork flavorutil.setLocalFlags(localFlags) packageName = name.split(':')[0] # this shouldn't matter for group recipes as it will get overridden # by the behavior in cookGroupObject. But it matters for some other # recipe types. That should be fixed and all that code should be # moved inside cookObject so I could get rid of this. use.setBuildFlagsFromFlavor(packageName, cfg.buildFlavor, error=False) use.resetUsed() use.setUsed(usedFlags) # we don't want to sign packages here, if necessary, we can sign # them at a higher level. cfg.signatureKeyMap = {} cfg.signatureKey = None crossCompile = flavorutil.getCrossCompile(cfg.buildFlavor) # add extra buildreqs manually added for this trove # by the builder. Only add them if the recipe is of the # right type, and the cfg file we're passed in understands them # (it might be a simple conary cfg file). if (hasattr(recipeClasses[0], 'buildRequires') and hasattr(cfg, 'defaultBuildReqs')):
try: # get the correct environment variables from this root # some packages depend on environment variables e.g. $QTDIR that # are set by other packages. setupEnvironment() # now override flags set in flavor # don't need to reset this flavor ever, because # we are in a fork flavorutil.setLocalFlags(localFlags) packageName = name.split(':')[0] # this shouldn't matter for group recipes as it will get overridden # by the behavior in cookGroupObject. But it matters for some other # recipe types. That should be fixed and all that code should be # moved inside cookObject so I could get rid of this. use.setBuildFlagsFromFlavor(packageName, cfg.buildFlavor, error=False) use.resetUsed() use.setUsed(usedFlags) # we don't want to sign packages here, if necessary, we can sign # them at a higher level. cfg.signatureKeyMap = {} cfg.signatureKey = None crossCompile = flavorutil.getCrossCompile(cfg.buildFlavor) # add extra buildreqs manually added for this trove # by the builder. Only add them if the recipe is of the # right type, and the cfg file we're passed in understands them # (it might be a simple conary cfg file). if (hasattr(recipeClasses[0], 'buildRequires')
def testTargetFlavor(self): use.setBuildFlagsFromFlavor(None, self.cfg.buildFlavor, error=False) targetFlavor = str(use.createFlavor(None, use.Arch._iterAll(), targetDep=True)) assert(targetFlavor) flavor = str(use.createFlavor(None, use.Arch._iterAll(), targetDep=False)) assert(targetFlavor.replace('target', 'is') == flavor)
def getBuildJob(buildConfig, conaryclient, troveSpecList, message=None, recurseGroups=BUILD_RECURSE_GROUPS_NONE, configDict=None, oldTroveDict=None, updateSpecs=None, rebuild=False): trovesByContext = {} for troveSpec in list(troveSpecList): if not isinstance(troveSpec, tuple): troveSpec = cmdutil.parseTroveSpec(troveSpec) if len(troveSpec) == 3: context = '' else: context = troveSpec[3] troveSpec = troveSpec[:3] if troveSpec[2] is None: troveSpec = (troveSpec[0], troveSpec[1], deps.parseFlavor('')) trovesByContext.setdefault(context, []).append(troveSpec) job = buildjob.BuildJob() # don't store all the contexts with this job - they're useless past the # initialization step. if configDict: mainConfig = configDict[''] job.setMainConfig(configDict['']) else: cfg = copy.deepcopy(buildConfig) cfg.dropContexts() mainConfig = cfg mainConfig.recurseGroups = int(recurseGroups) job.setMainConfig(mainConfig) baseMatchRules = mainConfig.matchTroveRule for contextStr, troveSpecList in trovesByContext.iteritems(): contextBaseMatchRules = baseMatchRules if configDict and contextStr in configDict: cfg = configDict[contextStr] elif contextStr: # making this a copy is critical cfg = copy.deepcopy(buildConfig) for context in contextStr.split(','): cfg.setContext(context) cfg.dropContexts() else: # don't bother with baseMatchRules in the base config. contextBaseMatchRules = [] cfg = copy.deepcopy(buildConfig) cfg.dropContexts() contextStr = '' job.setMainConfig(cfg) cfg.initializeFlavors() use.setBuildFlagsFromFlavor(None, cfg.buildFlavor, error=False) if not cfg.buildLabel and cfg.installLabelPath: cfg.buildLabel = cfg.installLabelPath[0] troveSpecList = list(set(troveSpecList)) troveList = getTrovesToBuild(cfg, conaryclient, troveSpecList, message=None, recurseGroups=recurseGroups, matchSpecs=contextBaseMatchRules + cfg.matchTroveRule, reposName=mainConfig.reposName, updateSpecs=updateSpecs) if updateSpecs and oldTroveDict and contextStr in oldTroveDict: troveList = _matchUpdateRestrictions(mainConfig.reposName, oldTroveDict[contextStr], troveList, updateSpecs) if rebuild: prebuiltBinaries = _findLatestBinariesForTroves(conaryclient, mainConfig.reposName, troveList) if not job.getMainConfig().prebuiltBinaries: job.getMainConfig().prebuiltBinaries = prebuiltBinaries else: job.getMainConfig().prebuiltBinaries.extend(prebuiltBinaries) if mainConfig.prepOnly: buildType = buildtrove.TROVE_BUILD_TYPE_PREP else: buildType = buildtrove.TROVE_BUILD_TYPE_NORMAL for name, version, flavor in troveList: if flavor is None: flavor = deps.parseFlavor('') bt = buildtrove.BuildTrove(None, name, version, flavor, context=contextStr, buildType=buildType) job.addTrove(name, version, flavor, contextStr, bt) job.setTroveConfig(bt, cfg) return job
def testCrossCompileSetup(self): siteConfigPath = os.path.abspath(resources.get_archive('site')) def _checkSite(macros, *paths): self.assertEquals(macros.env_siteconfig, ' '.join([siteConfigPath + '/' + x for x in paths])) self.cfg.siteConfigPath = [ siteConfigPath] oldPath = os.environ['PATH'] try: self.addTestPkg(1) repos = self.openRepository() if 'CONFIG_SITE' in os.environ: del os.environ['CONFIG_SITE'] loader = loadrecipe.recipeLoaderFromSourceComponent('test1:source', self.cfg, repos)[0] recipeClass = loader.getRecipe() self.overrideBuildFlavor('is:x86(!i686,!i586,i486)') use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) nocross = recipeClass(self.cfg, None, None, {}) assert(nocross.macros.target == 'i486-unknown-linux') assert(nocross.macros.host == 'i486-unknown-linux') assert(nocross.macros.build == 'i486-unknown-linux') assert(not nocross.isCrossCompiling()) assert(not nocross.isCrossCompileTool()) assert(not nocross.needsCrossFlags()) if 'CONFIG_SITE' in os.environ: del os.environ['CONFIG_SITE'] use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) try: invalid = recipeClass(self.cfg, None, None, {}, (None, '((', False)) except errors.CookError: pass # cross compiling something for x86_64 cross1 = recipeClass(self.cfg, None, None, {}, (None, 'x86_64', False)) assert(cross1.macros.target == 'x86_64-unknown-linux') assert(cross1.macros.host == 'x86_64-unknown-linux') assert(cross1.macros.build == 'i486-unknown-linux') assert(cross1.hostmacros.lib == 'lib64') assert(cross1.targetmacros.lib == 'lib64') assert(cross1.buildmacros.lib == 'lib') assert(cross1.macros.lib == 'lib64') assert(cross1.isCrossCompiling()) assert(not cross1.isCrossCompileTool()) assert(cross1.needsCrossFlags()) assert(use.Arch.x86_64) _checkSite(cross1.macros, 'x86_64', 'linux') _checkSite(cross1.buildmacros, 'x86', 'linux') _checkSite(cross1.hostmacros, 'x86_64', 'linux') if 'CONFIG_SITE' in os.environ: del os.environ['CONFIG_SITE'] use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) # building a cross compiling tool for i686 cross2 = recipeClass(self.cfg, None, None, {}, (None, 'x86(i686)', True)) assert(cross2.macros.target == 'i686-unknown-linux') assert(cross2.macros.host == 'i486-unknown-linux') # note the added _build here to differentiate host from build assert(cross2.macros.build == 'i486-unknown_build-linux') assert(use.Arch.x86.i686) # building a cross-compiler on i386 to run on x86_64 to compile # for ppc use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) if 'CONFIG_SITE' in os.environ: del os.environ['CONFIG_SITE'] cross3 = recipeClass(self.cfg, None, None, {}, ('x86_64', 'ppc', True)) assert(cross3.macros.target == 'powerpc-unknown-linux') assert(cross3.macros.host == 'x86_64-unknown-linux') assert(cross3.macros.build == 'i486-unknown-linux') assert(cross3.macros.cc == 'i486-unknown-linux-gcc') assert(cross3.macros.cxx == 'i486-unknown-linux-g++') # this is a cross-tool, so we're building for the system machine # so buildcc == cc assert(cross3.macros.buildcc == 'i486-unknown-linux-gcc') assert(cross3.macros.buildcxx == 'i486-unknown-linux-g++') assert(cross3.macros.lib == 'lib') assert(cross3.hostmacros.lib == 'lib64') assert(cross3.targetmacros.lib == 'lib') assert(cross3.buildmacros.lib == 'lib') assert(use.Arch.x86_64) assert(not cross3.isCrossCompiling()) assert(cross3.isCrossCompileTool()) assert(cross3.needsCrossFlags()) # When creating a cross compiler for a ppc system # on an x86_64 box, configure should return results for the x86_64 # box, not the target arch. _checkSite(cross3.macros, 'x86_64', 'linux') _checkSite(cross3.buildmacros, 'x86', 'linux') _checkSite(cross3.hostmacros, 'x86_64', 'linux') # cross compiling for i486 on i486 # buildcc should have /usr/bin/ in front use.setBuildFlagsFromFlavor('test1', self.cfg.buildFlavor) if 'CONFIG_SITE' in os.environ: del os.environ['CONFIG_SITE'] cross4 = recipeClass(self.cfg, None, None, {}, (None, 'x86(i486)', False)) assert(cross4.macros.target == 'i486-unknown-linux') assert(cross4.macros.host == 'i486-unknown-linux') assert(cross4.macros.build == 'i486-unknown_build-linux') assert(cross4.macros.buildcc == '/usr/bin/i486-unknown-linux-gcc') assert(cross4.macros.buildcxx == '/usr/bin/i486-unknown-linux-g++') assert(cross4.macros.cc == 'i486-unknown-linux-gcc') assert(cross4.macros.cxx == 'i486-unknown-linux-g++') finally: os.environ['PATH'] = oldPath
def getRecipeObj( repos, name, version, flavor, trv, loadInstalledSource=None, installLabelPath=None, loadRecipeSpecs=None, buildLabel=None, groupRecipeSource=None, cfg=None, ): if cfg: cfg = copy.deepcopy(cfg) else: cfg = conarycfg.ConaryConfiguration(False) cfg.initializeFlavors() branch = version.branch() if not buildLabel: buildLabel = version.branch().label() if not installLabelPath: cfg.installLabelPath = [buildLabel] else: cfg.installLabelPath = installLabelPath cfg.buildFlavor = flavor cfg.defaultBasePackages = [] name = name.split(":")[0] use.LocalFlags._clear() assert flavorutil.getArch(flavor) use.setBuildFlagsFromFlavor(name, flavor, error=False) use.resetUsed() use.track(True) ignoreInstalled = not loadInstalledSource macros = {"buildlabel": buildLabel.asString(), "buildbranch": version.branch().asString()} cfg.lookaside = tempfile.mkdtemp() try: loader = RecipeLoaderFromSourceTrove( trv, repos, cfg, name + ":source", branch, ignoreInstalled=ignoreInstalled, db=loadInstalledSource, buildFlavor=flavor, ) recipeClass = loader.getRecipe() recipeClass._trove = trv if recipe.isGroupRecipe(recipeClass): recipeObj = recipeClass(repos, cfg, buildLabel, flavor, None, extraMacros=macros) recipeObj.sourceVersion = version recipeObj.loadPolicy() recipeObj.setup() elif ( recipe.isPackageRecipe(recipeClass) or recipe.isFactoryRecipe(recipeClass) or recipe.isCapsuleRecipe(recipeClass) ): if recipe.isFactoryRecipe(recipeClass): # This requires a specific capability in conary compat.ConaryVersion().requireFactoryRecipeGeneration() # Load the FactoryRecipe factoryClass = recipeClass loaded = cook.loadFactoryRecipe(factoryClass, cfg, repos, flavor) recipeClass = loaded.getRecipe() lcache = lookaside.RepositoryCache(repos) recipeObj = recipeClass(cfg, lcache, [], macros, lightInstance=True) recipeObj.sourceVersion = version recipeObj.populateLcache() if not recipeObj.needsCrossFlags(): recipeObj.crossRequires = [] recipeObj.loadPolicy() recipeObj.setup() elif recipe.isInfoRecipe(recipeClass): recipeObj = recipeClass(cfg, None, None, macros) recipeObj.sourceVersion = version recipeObj.setup() elif recipe.isRedirectRecipe(recipeClass): binaryBranch = version.getBinaryVersion().branch() recipeObj = recipeClass(repos, cfg, binaryBranch, flavor) recipeObj.sourceVersion = version recipeObj.setup() elif recipe.isFileSetRecipe(recipeClass): recipeObj = recipeClass(repos, cfg, buildLabel, flavor, extraMacros=macros) recipeObj.sourceVersion = version recipeObj.setup() else: raise RuntimeError, "Unknown class type %s for recipe %s" % (recipeClass, name) finally: util.rmtree(cfg.lookaside) return recipeObj, loader
def getRecipeObj(repos, name, version, flavor, trv, loadInstalledSource=None, installLabelPath=None, loadRecipeSpecs=None, buildLabel=None, groupRecipeSource=None, cfg=None): if cfg: cfg = copy.deepcopy(cfg) else: cfg = conarycfg.ConaryConfiguration(False) cfg.initializeFlavors() branch = version.branch() if not buildLabel: buildLabel = version.branch().label() if not installLabelPath: cfg.installLabelPath = [buildLabel] else: cfg.installLabelPath = installLabelPath cfg.buildFlavor = flavor cfg.defaultBasePackages = [] name = name.split(':')[0] use.LocalFlags._clear() assert (flavorutil.getArch(flavor)) use.setBuildFlagsFromFlavor(name, flavor, error=False) use.resetUsed() use.track(True) ignoreInstalled = not loadInstalledSource macros = { 'buildlabel': buildLabel.asString(), 'buildbranch': version.branch().asString() } cfg.lookaside = tempfile.mkdtemp() try: loader = RecipeLoaderFromSourceTrove(trv, repos, cfg, name + ':source', branch, ignoreInstalled=ignoreInstalled, db=loadInstalledSource, buildFlavor=flavor) recipeClass = loader.getRecipe() recipeClass._trove = trv if recipe.isGroupRecipe(recipeClass): recipeObj = recipeClass(repos, cfg, buildLabel, flavor, None, extraMacros=macros) recipeObj.sourceVersion = version recipeObj.loadPolicy() recipeObj.setup() elif (recipe.isPackageRecipe(recipeClass) or recipe.isFactoryRecipe(recipeClass) or recipe.isCapsuleRecipe(recipeClass)): if recipe.isFactoryRecipe(recipeClass): #This requires a specific capability in conary compat.ConaryVersion().requireFactoryRecipeGeneration() #Load the FactoryRecipe factoryClass = recipeClass loaded = cook.loadFactoryRecipe(factoryClass, cfg, repos, flavor) recipeClass = loaded.getRecipe() lcache = lookaside.RepositoryCache(repos) recipeObj = recipeClass(cfg, lcache, [], macros, lightInstance=True) recipeObj.sourceVersion = version recipeObj.populateLcache() if not recipeObj.needsCrossFlags(): recipeObj.crossRequires = [] recipeObj.loadPolicy() recipeObj.setup() elif recipe.isInfoRecipe(recipeClass): recipeObj = recipeClass(cfg, None, None, macros) recipeObj.sourceVersion = version recipeObj.setup() elif recipe.isRedirectRecipe(recipeClass): binaryBranch = version.getBinaryVersion().branch() recipeObj = recipeClass(repos, cfg, binaryBranch, flavor) recipeObj.sourceVersion = version recipeObj.setup() elif recipe.isFileSetRecipe(recipeClass): recipeObj = recipeClass(repos, cfg, buildLabel, flavor, extraMacros=macros) recipeObj.sourceVersion = version recipeObj.setup() else: raise RuntimeError, 'Unknown class type %s for recipe %s' % ( recipeClass, name) finally: util.rmtree(cfg.lookaside) return recipeObj, loader