def __init__(self, cfg): recipe.Recipe.__init__(self, cfg) self.macros = macros.Macros() self.macros.update(recipe.loadMacros(cfg.defaultMacros)) self.theMainDir = 'dummy-1.0' self.macros.builddir = tempfile.mkdtemp() self.macros.destdir = tempfile.mkdtemp() self.macros.maindir = self.theMainDir self.srcdirs = [cfg.sourceSearchDir] self.buildinfo = buildinfo.BuildInfo(self.macros.builddir) self.buildinfo.begin() self.laReposCache = lookaside.RepositoryCache(None, cfg=cfg) self.fileFinder = lookaside.FileFinder('dummy', self.laReposCache, self.srcdirs, {}, cfg.mirrorDirs) self.name = 'dummy' self.version = '1.0' self.explicitMainDir = False self._derivedFiles = {}
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 testDuplicateBasenames(self): self.resetCache() self.resetWork() self.resetRepository() repos = self.openRepository() cfg = self.cfg repCache = lookaside.RepositoryCache(repos, cfg=cfg) try: contentServer = rephelp.HTTPServerController(getRequester()) contentURL = contentServer.url() origDir = os.getcwd() os.chdir(self.workDir) self.newpkg('test') os.chdir('test') testdir = '/'.join((self.workDir, 'test')) log.setVerbosity(log.INFO) self.logFilter.add() # first, look for a file that does not exist assert lookaside.findAll(self.cfg, repCache, contentURL + '/404/foo', 'test', (testdir, ), allowNone=True) is None # make sure that we got a negative cache entry assert os.stat(self.cacheDir + '/NEGATIVE/test/404/foo') # now look for a file that does exist assert lookaside.findAll(self.cfg, repCache, contentURL + '/200/foo', 'test', (testdir, ), allowNone=True) is not None # make sure that we got a the cache entry assert os.stat(self.cacheDir + '/test/200/foo') # put two different files with the same name name in the cache fooDir = os.path.join(self.cacheDir, 'test/foo.conary.com/foo/') os.makedirs(fooDir) self.writeFile(os.path.join(fooDir, 'theFile'), 'Foo version of the file\n') barDir = os.path.join(self.cacheDir, 'test/bar.conary.com/bar/') os.makedirs(barDir) self.writeFile(os.path.join(barDir, 'theFile'), 'Bar version of the file\n') # this file shouldn't be found path = lookaside.findAll(self.cfg, repCache, 'http://baz.conary.com/foo/theFile', 'test', (testdir, ), allowNone=True) self.assertEqual(path, None) # this file should be found and have the right contents path = lookaside.findAll(self.cfg, repCache, 'http://foo.conary.com/foo/theFile', 'test', (testdir, ), allowNone=True) f = open(path) self.assertEqual(f.readline()[0:3], 'Foo') f.close() # so should this one path = lookaside.findAll(self.cfg, repCache, 'http://bar.conary.com/bar/theFile', 'test', (testdir, ), allowNone=True) f = open(path) self.assertEqual(f.readline()[0:3], 'Bar') f.close() finally: contentServer.kill()
def __init__(self, cfg, lightInstance=False, laReposCache=None, srcdirs=None): if laReposCache is None: laReposCache = lookaside.RepositoryCache(None) assert (self.__class__ is not Recipe) self.validate() self.cfg = cfg self.externalMethods = {} # lightInstance for only instantiating, not running (such as checkin) self._lightInstance = lightInstance self._sources = [] self.loadSourceActions() self.buildinfo = None self.metadataSkipSet = [ 'keyValue', ] self.laReposCache = laReposCache self.srcdirs = srcdirs self.sourcePathMap = {} self.pathConflicts = {} self._recordMethodCalls = False self.methodsCalled = [] self.unusedMethods = set() self.methodDepth = 0 self._pathTranslations = [] self._repos = None self._capsulePathMap = {} self._capsulePackageMap = {} self._capsuleDataMap = {} self._capsules = {} self._lcstate = None self._propertyMap = {} baseMacros = loadMacros(cfg.defaultMacros) self.macros = macros.Macros(ignoreUnknown=lightInstance) self.macros.update(baseMacros) # Metadata is a hash keyed on a trove name and with a list of # per-trove-name MetadataItem like objects (well, dictionaries) self._metadataItemsMap = {} # Old metadata, keyed on trove name, with ((n, v, f), metadata, log) # as value self._oldMetadataMap = {} self._filteredKeyValueMetadata = set() # Multi-URL map, used for multiple URL support in addArchive et al self.multiurlMap = {} # Search method for sources self.cookType = self.COOK_TYPE_LOCAL superClasses = self.__class__.__mro__ for itemName in dir(self): if itemName[0] == '_': continue item = getattr(self, itemName) if inspect.ismethod(item): if item.im_class == type: # classmethod continue className = self.__class__.__name__ for class_ in superClasses: classItem = getattr(class_, itemName, None) if classItem is None: continue if classItem.im_func == item.im_func: className = class_.__name__ if className in [ 'Recipe', 'AbstractPackageRecipe', 'SourcePackageRecipe', 'BaseRequiresRecipe', 'GroupRecipe', '_GroupRecipe', 'GroupSetRecipe', '_GroupSetRecipe', 'RedirectRecipe', 'AbstractDerivedPackageRecipe', 'DerivedPackageRecipe', 'AbstractDerivedCapsuleRecipe', 'DerivedCapsuleRecipe', 'FilesetRecipe', '_BaseGroupRecipe' ]: continue setattr(self, itemName, self._wrapMethod(className, item)) self.unusedMethods.add((className, item.__name__)) # Inspected only when it is important to know for reporting # purposes what was specified in the recipe per se, and not # in superclasses or in defaultBuildRequires self._recipeRequirements = { 'buildRequires': list(self.buildRequires), 'crossRequires': list(self.crossRequires) } self._includeSuperClassBuildReqs() self._includeSuperClassCrossReqs() self.transitiveBuildRequiresNames = None self._subscribeLogPath = None self._subscribedPatterns = [] self._logFile = None self._isCrossCompileTool = False self._isCrossCompiling = False
def testLookAsideTest1(self): raise testhelp.SkipTestException( "tests shouldn't talk to the internet") self.resetCache() self.resetWork() self.resetRepository() repos = self.openRepository() cfg = self.cfg repCache = lookaside.RepositoryCache(repos, cfg=cfg) origDir = os.getcwd() os.chdir(self.workDir) self.newpkg('test') os.chdir('test') testdir = '/'.join((self.workDir, 'test')) log.setVerbosity(log.INFO) self.logFilter.add() # first, look for a file that does not exist assert (lookaside.findAll(self.cfg, repCache, 'http://example.conary.com/foo', 'test', (testdir, ), allowNone=True) is None) # make sure that we got a negative cache entry assert (os.stat('/'.join( (self.cacheDir, 'NEGATIVE/test/example.conary.com/foo')))) # now make sure that this works for ftp as well (urllib workaround) # XXX WORKAROUND until FTP works in eng lab #assert(lookaside.findAll(self.cfg, repCache, # 'ftp://download.rpath.com/blah', 'test', (testdir,), # allowNone=True) is None) # make sure that we got a negative cache entry #assert(os.stat('/'.join((self.cacheDir, # 'NEGATIVE/test/download.rpath.com/blah')))) # now we put a file in place f = file(os.sep.join((testdir, 'bar')), 'w') f.write('this is a test') f.close() c = lookaside.findAll(self.cfg, repCache, 'bar', 'test', (testdir, )) # it does not need to cache it; it is known to exist assert (c == os.sep.join((testdir, 'bar'))) # Test httpHeaders: c = util.normpath( lookaside.findAll(self.cfg, repCache, 'http://www.google.com/preferences', 'test', (testdir, ), httpHeaders={'Accept-Language': 'es-es'})) assert (c == '/'.join( (self.cacheDir, 'test/www.google.com/preferences'))) #open the page and check to see if it's in spanish f = open(c) contents = f.read() f.close() assert 'Preferencias globales' in contents # we need a web page to actually test the cache in operation # we do it a second time to make sure that the cache works for i in (0, 1): c = util.normpath( lookaside.findAll(self.cfg, repCache, 'http://wiki.rpath.com/wiki/Main_Page', 'test', (testdir, ))) assert (c == '/'.join( (self.cacheDir, 'test/wiki.rpath.com/wiki/Main_Page'))) self.logFilter.remove() self.logFilter.compare(( '+ Trying http://example.conary.com/foo...', # XXX WORKAROUND until FTP works in eng lab #'+ Trying ftp://download.rpath.com/blah...', #'+ Downloading ftp://download.rpath.com/blah...', '+ Trying http://www.google.com/preferences...', '+ Downloading http://www.google.com/preferences...', '+ Trying http://wiki.rpath.com/wiki/Main_Page...', '+ Downloading http://wiki.rpath.com/wiki/Main_Page...')) recipestr = """ class TestLookaside(PackageRecipe): name = 'test' version = '1' clearBuildReqs() def setup(r): r.addSource('bar', dest='/') """ self.writeFile('test.recipe', recipestr) self.addfile('test.recipe') self.addfile('bar', binary=True) self.commit() os.chdir(origDir) # ensure that a localOnly=True lookup in the repository works; # for this, we need a prepped recipeObj for its RepositoryCache # object recipeObj = self.getRecipeObjFromRepos('test', repos) self.logFilter.add() c = lookaside.findAll(self.cfg, recipeObj.laReposCache, 'bar', 'test', (), localOnly=True) self.logFilter.remove() self.logFilter.compare('+ found bar in repository', ) assert (c == os.sep.join((self.cacheDir, 'test', 'bar')))