Source Code for Module yum.repos

  1  #!/usr/bin/python -tt 
  2  # This program is free software; you can redistribute it and/or modify 
  3  # it under the terms of the GNU General Public License as published by 
  4  # the Free Software Foundation; either version 2 of the License, or 
  5  # (at your option) any later version. 
  6  # 
  7  # This program is distributed in the hope that it will be useful, 
  8  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
  9  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 10  # GNU Library General Public License for more details. 
 11  # 
 12  # You should have received a copy of the GNU General Public License 
 13  # along with this program; if not, write to the Free Software 
 14  # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
 15  # Copyright 2004 Duke University  
 16   
 17  import re 
 18  import fnmatch 
 19  import types 
 20  import logging 
 21  import misc 
 22   
 23  import Errors 
 24  from packageSack import MetaSack 
 25   
 26  from weakref import proxy as weakref 
 27   
 28 -class _wrap_ayum_getKeyForRepo: 
 29      """ This is a wrapper for calling YumBase.getKeyForRepo() because 
 30          otherwise we take a real reference through the bound method and 
 31          that is d00m (this applies to YumBase and RepoStorage, hence why 
 32          we have a seperate class). 
 33          A "better" fix might be to explicitly pass the YumBase instance to 
 34          the callback ... API change! """ 
 35 -    def __init__(self, ayum): 
 36          self.ayum = weakref(ayum) 
 37 -    def __call__(self, repo, callback=None): 
 38          return self.ayum.getKeyForRepo(repo, callback) 
 39   
 40 -class RepoStorage: 
 41      """This class contains multiple repositories and core configuration data 
 42         about them.""" 
 43          
 44 -    def __init__(self, ayum): 
 45          self.repos = {} # list of repos by repoid pointing a repo object  
 46                          # of repo options/misc data 
 47          self.callback = None # progress callback used for populateSack() for importing the xml files 
 48          self.cache = 0 
 49          self.pkgSack = MetaSack() 
 50          self.logger = logging.getLogger("yum.RepoStorage") 
 51   
 52          self._setup = False 
 53   
 54          self.ayum = weakref(ayum) 
 55          # callbacks for handling gpg key imports for repomd.xml sig checks 
 56          # need to be set from outside of the repos object to do anything 
 57          # even quasi-useful 
 58          # defaults to what is probably sane-ish 
 59          self.gpg_import_func = _wrap_ayum_getKeyForRepo(ayum) 
 60          self.confirm_func = None 
 61   
 62          # This allow listEnabled() to be O(1) most of the time. 
 63          self._cache_enabled_repos = [] 
 64          self.quick_enable_disable = {} 
 65   
 66 -    def doSetup(self, thisrepo = None): 
 67           
 68          self.ayum.plugins.run('prereposetup') 
 69           
 70          if thisrepo is None: 
 71              repos = self.listEnabled() 
 72          else: 
 73              repos = self.findRepos(thisrepo) 
 74   
 75          if len(repos) < 1: 
 76              self.logger.debug('No Repositories Available to Set Up') 
 77   
 78          for repo in repos: 
 79              repo.setup(self.ayum.conf.cache, self.ayum.mediagrabber, 
 80                     gpg_import_func = self.gpg_import_func, confirm_func=self.confirm_func) 
 81   
 82          self._setup = True 
 83          self.ayum.plugins.run('postreposetup') 
 84           
 85 -    def __str__(self): 
 86          return str(self.repos.keys()) 
 87   
 88 -    def __del__(self): 
 89          self.close() 
 90   
 91 -    def close(self): 
 92          for repo in self.repos.values(): 
 93              repo.close() 
 94   
 95 -    def add(self, repoobj): 
 96          if repoobj.id in self.repos: 
 97              raise Errors.DuplicateRepoError, 'Repository %s is listed more than once in the configuration' % (repoobj.id) 
 98          self.repos[repoobj.id] = repoobj 
 99          if hasattr(repoobj, 'quick_enable_disable'): 
100              self.quick_enable_disable.update(repoobj.quick_enable_disable) 
101              repoobj.quick_enable_disable = self.quick_enable_disable 
102          else: 
103              self._cache_enabled_repos = None 
104   
105 -    def delete(self, repoid): 
106          if self.repos.has_key(repoid): 
107              thisrepo = self.repos[repoid] 
108              thisrepo.close() 
109              del self.repos[repoid] 
110               
111 -    def sort(self): 
112          repolist = self.repos.values() 
113          repolist.sort() 
114          return repolist 
115           
116 -    def getRepo(self, repoid): 
117          try: 
118              return self.repos[repoid] 
119          except KeyError, e: 
120              raise Errors.RepoError, \ 
121                  'Error getting repository data for %s, repository not found' % (repoid) 
122   
123 -    def findRepos(self,pattern): 
124          """find all repositories matching fnmatch `pattern`""" 
125   
126          result = [] 
127           
128          for item in pattern.split(','): 
129              item = item.strip() 
130              match = re.compile(fnmatch.translate(item)).match 
131              for name,repo in self.repos.items(): 
132                  if match(name): 
133                      result.append(repo) 
134          return result 
135           
136 -    def disableRepo(self, repoid): 
137          """disable a repository from use 
138           
139          fnmatch wildcards may be used to disable a group of repositories. 
140          returns repoid of disabled repos as list 
141          """ 
142          repos = [] 
143          if misc.re_glob(repoid) or repoid.find(',') != -1: 
144              for repo in self.findRepos(repoid): 
145                  repos.append(repo.id) 
146                  repo.disable() 
147          else: 
148              thisrepo = self.getRepo(repoid) 
149              repos.append(thisrepo.id) 
150              thisrepo.disable() 
151           
152          return repos 
153           
154 -    def enableRepo(self, repoid): 
155          """enable a repository for use 
156           
157          fnmatch wildcards may be used to enable a group of repositories. 
158          returns repoid of enables repos as list 
159          """ 
160          repos = [] 
161          if misc.re_glob(repoid) or repoid.find(',') != -1: 
162              for repo in self.findRepos(repoid): 
163                  repos.append(repo.id) 
164                  repo.enable() 
165          else: 
166              thisrepo = self.getRepo(repoid) 
167              repos.append(thisrepo.id) 
168              thisrepo.enable() 
169           
170          return repos 
171           
172 -    def listEnabled(self): 
173          """return list of enabled repo objects""" 
174   
175          if (self._cache_enabled_repos is not None and 
176              not self.quick_enable_disable): 
177              return self._cache_enabled_repos 
178   
179          returnlist = [] 
180          for repo in self.repos.values(): 
181              if repo.isEnabled(): 
182                  returnlist.append(repo) 
183   
184          returnlist.sort() 
185   
186          if self._cache_enabled_repos is not None: 
187              self._cache_enabled_repos = returnlist 
188              self.quick_enable_disable.clear() 
189          return returnlist 
190   
191 -    def listGroupsEnabled(self): 
192          """return a list of repo objects that have groups enabled""" 
193          returnlist = [] 
194          for repo in self.listEnabled(): 
195              if repo.enablegroups: 
196                  returnlist.append(repo) 
197   
198          return returnlist 
199   
200 -    def setCache(self, cacheval): 
201          """sets cache value in all repos""" 
202          self.cache = cacheval 
203          for repo in self.repos.values(): 
204              repo.cache = cacheval 
205   
206 -    def setCacheDir(self, cachedir): 
207          """sets the cachedir value in all repos""" 
208           
209          self._cachedir = cachedir 
210          for repo in self.repos.values(): 
211              repo.old_base_cache_dir = repo.basecachedir 
212              repo.basecachedir = cachedir 
213               
214   
215 -    def setProgressBar(self, obj): 
216          """sets the progress bar for downloading files from repos""" 
217           
218          for repo in self.repos.values(): 
219              repo.setCallback(obj) 
220   
221 -    def setFailureCallback(self, obj): 
222          """sets the failure callback for all repos""" 
223           
224          for repo in self.repos.values(): 
225              repo.setFailureObj(obj) 
226   
227 -    def setMirrorFailureCallback(self, obj): 
228          """sets the failure callback for all mirrors""" 
229           
230          for repo in self.repos.values(): 
231              repo.setMirrorFailureObj(obj) 
232   
233 -    def setInterruptCallback(self, callback): 
234          for repo in self.repos.values(): 
235              repo.setInterruptCallback(callback) 
236   
237 -    def getPackageSack(self): 
238          return self.pkgSack 
239   
240   
241 -    def populateSack(self, which='enabled', mdtype='metadata', callback=None, cacheonly=0): 
242          """ 
243          This populates the package sack from the repositories, two optional  
244          arguments: 
245              - which='repoid, enabled, all' 
246              - mdtype='metadata, filelists, otherdata, all' 
247          """ 
248   
249          if not self._setup: 
250              self.doSetup() 
251   
252          if not callback: 
253              callback = self.callback 
254          myrepos = [] 
255          if which == 'enabled': 
256              myrepos = self.listEnabled() 
257          elif which == 'all': 
258              myrepos = self.repos.values() 
259          else: 
260              if type(which) == types.ListType: 
261                  for repo in which: 
262                      if isinstance(repo, Repository): 
263                          myrepos.append(repo) 
264                      else: 
265                          repobj = self.getRepo(repo) 
266                          myrepos.append(repobj) 
267              elif type(which) == types.StringType: 
268                  repobj = self.getRepo(which) 
269                  myrepos.append(repobj) 
270   
271          if mdtype == 'all': 
272              data = ['metadata', 'filelists', 'otherdata'] 
273          else: 
274              data = [ mdtype ] 
275            
276          for repo in myrepos: 
277              sack = repo.getPackageSack() 
278              try: 
279                  sack.populate(repo, mdtype, callback, cacheonly) 
280              except Errors.RepoError, e: 
281                  if mdtype in ['all', 'metadata'] and repo.skip_if_unavailable: 
282                      self.disableRepo(repo.id) 
283                  else: 
284                      raise 
285              else: 
286                  self.pkgSack.addSack(repo.id, sack) 
287   
288   
289 -class Repository: 
290      """this is an actual repository object"""        
291   
292 -    def __init__(self, repoid): 
293          self.id = repoid 
294          self.quick_enable_disable = {} 
295          self.disable() 
296          self._xml2sqlite_local = False 
297   
298 -    def __cmp__(self, other): 
299          """ Sort base class repos. by alphanumeric on their id, also 
300              see __cmp__ in YumRepository(). """ 
301          if self.id > other.id: 
302              return 1 
303          elif self.id < other.id: 
304              return -1 
305          else: 
306              return 0 
307   
308 -    def __str__(self): 
309          return self.id 
310   
311 -    def __hash__(self): 
312          return hash(self.id) 
313           
314 -    def __del__(self): 
315          self.close() 
316   
317 -    def close(self): 
318          pass 
319   
320 -    def setAttribute(self, key, value): 
321          """sets a generic attribute of this repository""" 
322          setattr(self, key, value) 
323   
324 -    def getAttribute(self, key): 
325          return getattr(self, key, None) 
326   
327 -    def isEnabled(self): 
328          enabled = self.getAttribute('enabled') 
329          return enabled is not None and enabled 
330   
331 -    def enable(self): 
332          self.setAttribute('enabled', 1) 
333          self.quick_enable_disable[self.id] = True 
334                       
335 -    def disable(self): 
336          self.setAttribute('enabled', 0) 
337          self.quick_enable_disable[self.id] = False 
338   
339 -    def getExcludePkgList(self): 
340          excludeList = self.getAttribute('exclude') 
341          return excludeList or [] 
342   
343 -    def getIncludePkgList(self): 
344          includeList = self.getAttribute('includepkgs') 
345          return includeList or [] 
346   
347      # Abstract interface 
348 -    def ready(self): 
349          raise NotImplementedError() 
350   
351 -    def getGroupLocation(self): 
352          raise NotImplementedError() 
353    
354 -    def getPackageSack(self): 
355          raise NotImplementedError() 
356   
357 -    def setup(self, cache): 
358          raise NotImplementedError() 
359                       
360 -    def setCallback(self, callback): 
361          raise NotImplementedError() 
362   
363 -    def setFailureObj(self, obj): 
364          raise NotImplementedError() 
365   
366 -    def setMirrorFailureObj(self, obj): 
367          raise NotImplementedError() 
368   
369 -    def getPackage(self, package, checkfunc = None, text = None, cache = True): 
370          raise NotImplementedError() 
371   
372 -    def getHeader(self, package, checkfunc = None, reget = 'simple', cache = True): 
373          raise NotImplementedError() 
374