Source Code for Module entropy.client.interfaces.cache

  1  # -*- coding: utf-8 -*- 
  2  """ 
  3   
  4      @author: Fabio Erculiani <lxnay@sabayonlinux.org> 
  5      @contact: lxnay@sabayonlinux.org 
  6      @copyright: Fabio Erculiani 
  7      @license: GPL-2 
  8   
  9      B{Entropy Package Manager Client Cache Interface}. 
 10   
 11  """ 
 12  from __future__ import with_statement 
 13  import os 
 14  from entropy.const import * 
 15  from entropy.exceptions import * 
 16  from entropy.output import red, darkred, darkgreen 
 17  from entropy.i18n import _ 
 18   
 19 -class CacheMixin: 
 20   
 21 -    def validate_repositories_cache(self): 
 22          # is the list of repos changed? 
 23          cached = self.Cacher.pop(etpCache['repolist']) 
 24          if cached != self.SystemSettings['repositories']['order']: 
 25              # invalidate matching cache 
 26              try: 
 27                  self.repository_move_clear_cache() 
 28              except IOError: 
 29                  pass 
 30              self.store_repository_list_cache() 
 31   
 32 -    def store_repository_list_cache(self): 
 33          self.Cacher.push(etpCache['repolist'], 
 34              self.SystemSettings['repositories']['order'], 
 35              async = False) 
 36   
 37 -    def generate_cache(self, depcache = True, configcache = True, 
 38          client_purge = True, install_queue = True): 
 39   
 40          # clean first of all 
 41          self.purge_cache(client_purge = client_purge) 
 42          if depcache: 
 43              self.do_depcache(do_install_queue = install_queue) 
 44          if configcache: 
 45              self.do_configcache() 
 46   
 47 -    def do_configcache(self): 
 48          self.updateProgress( 
 49              darkred(_("Configuration files")), 
 50              importance = 2, 
 51              type = "warning" 
 52          ) 
 53          self.updateProgress( 
 54              red(_("Scanning hard disk")), 
 55              importance = 1, 
 56              type = "warning" 
 57          ) 
 58          self.FileUpdates.scanfs(dcache = False, quiet = True) 
 59          self.updateProgress( 
 60              darkred(_("Cache generation complete.")), 
 61              importance = 2, 
 62              type = "info" 
 63          ) 
 64   
 65 -    def do_depcache(self, do_install_queue = True): 
 66   
 67          self.updateProgress( 
 68              darkgreen(_("Resolving metadata")), 
 69              importance = 1, 
 70              type = "warning" 
 71          ) 
 72          # we can barely ignore any exception from here 
 73          # especially cases where client db does not exist 
 74          try: 
 75              update, remove, fine, spm_fine = self.calculate_world_updates() 
 76              del fine, spm_fine, remove 
 77              if do_install_queue: 
 78                  self.get_install_queue(update, False, False) 
 79              self.calculate_available_packages() 
 80          except: # except SystemDatabaseError @ calculate_world_updates 
 81              pass 
 82   
 83          self.updateProgress( 
 84              darkred(_("Dependencies cache filled.")), 
 85              importance = 2, 
 86              type = "warning" 
 87          ) 
 88   
 89 -    def purge_cache(self, showProgress = True, client_purge = True): 
 90          if self.entropyTools.is_user_in_entropy_group(): 
 91              self.Cacher.stop() 
 92              try: 
 93                  skip = set() 
 94                  if not client_purge: 
 95                      skip.add("/"+etpCache['dbMatch']+"/"+etpConst['clientdbid']) # it's ok this way 
 96                      skip.add("/"+etpCache['dbSearch']+"/"+etpConst['clientdbid']) # it's ok this way 
 97                  for key in etpCache: 
 98                      if showProgress: 
 99                          self.updateProgress( 
100                              darkred(_("Cleaning %s => dumps...")) % (etpCache[key],), 
101                              importance = 1, 
102                              type = "warning", 
103                              back = True 
104                          ) 
105                      self.clear_dump_cache(etpCache[key], skip = skip) 
106   
107                  if showProgress: 
108                      self.updateProgress( 
109                          darkgreen(_("Cache is now empty.")), 
110                          importance = 2, 
111                          type = "info" 
112                      ) 
113              finally: 
114                  self.Cacher.start() 
115   
116 -    def clear_dump_cache(self, dump_name, skip = []): 
117          self.Cacher.discard() 
118          self.SystemSettings._clear_dump_cache(dump_name, skip = skip) 
119   
120 -    def update_ugc_cache(self, repository): 
121          if not self.UGC.is_repository_eapi3_aware(repository): 
122              return None 
123          status = True 
124   
125          votes_dict, err_msg = self.UGC.get_all_votes(repository) 
126          if isinstance(votes_dict,dict): 
127              self.UGC.UGCCache.save_vote_cache(repository, votes_dict) 
128          else: 
129              status = False 
130   
131          downloads_dict, err_msg = self.UGC.get_all_downloads(repository) 
132          if isinstance(downloads_dict,dict): 
133              self.UGC.UGCCache.save_downloads_cache(repository, downloads_dict) 
134          else: 
135              status = False 
136          return status 
137   
138 -    def repository_move_clear_cache(self, repoid = None): 
139          return self.SystemSettings._clear_repository_cache(repoid = repoid) 
140   
141 -    def get_available_packages_chash(self): 
142          # client digest not needed, cache is kept updated 
143          return str(hash("%s|%s|%s" % ( 
144              self.all_repositories_checksum(), 
145              self.validRepositories, 
146              # needed when users do bogus things like editing config files 
147              # manually (branch setting) 
148              self.SystemSettings['repositories']['branch'], 
149              ) 
150          )) 
151   
152 -    def all_repositories_checksum(self): 
153          sum_hashes = '' 
154          for repo in self.validRepositories: 
155              try: 
156                  dbconn = self.open_repository(repo) 
157              except (RepositoryError): 
158                  continue # repo not available 
159              try: 
160                  sum_hashes += dbconn.checksum() 
161              except self.dbapi2.OperationalError: 
162                  pass 
163          return sum_hashes 
164   
165 -    def get_available_packages_cache(self, myhash = None): 
166          if myhash == None: 
167              myhash = self.get_available_packages_chash() 
168          return self.Cacher.pop("%s%s" % (etpCache['world_available'], myhash)) 
169   
170 -    def get_world_update_cache(self, empty_deps, db_digest = None): 
171   
172          misc_settings = self.SystemSettings[self.sys_settings_client_plugin_id]['misc'] 
173          ignore_spm_downgrades = misc_settings['ignore_spm_downgrades'] 
174   
175          if self.xcache: 
176   
177              if db_digest == None: 
178                  db_digest = self.all_repositories_checksum() 
179   
180              c_hash = "%s%s" % (etpCache['world_update'], 
181                  self.get_world_update_cache_hash(db_digest, empty_deps, 
182                      ignore_spm_downgrades),) 
183   
184              disk_cache = self.Cacher.pop(c_hash) 
185              if isinstance(disk_cache, tuple): 
186                  return disk_cache 
187   
188 -    def get_world_update_cache_hash(self, db_digest, empty_deps, 
189          ignore_spm_downgrades): 
190   
191          return str(hash("%s|%s|%s|%s|%s|%s" % ( 
192              db_digest, empty_deps, self.validRepositories, 
193              self.SystemSettings['repositories']['order'], 
194              ignore_spm_downgrades, 
195              # needed when users do bogus things like editing config files 
196              # manually (branch setting) 
197              self.SystemSettings['repositories']['branch'], 
198          ))) 
199   
200 -    def get_critical_updates_cache(self, db_digest = None): 
201   
202          if self.xcache: 
203   
204              if db_digest == None: 
205                  db_digest = self.all_repositories_checksum() 
206   
207              c_hash = "%s%s" % (etpCache['critical_update'], 
208                  self.get_critical_update_cache_hash(db_digest),) 
209   
210              return self.Cacher.pop(c_hash) 
211   
212 -    def get_critical_update_cache_hash(self, db_digest): 
213   
214          return str(hash("%s|%s|%s|%s" % ( 
215              db_digest, self.validRepositories, 
216              self.SystemSettings['repositories']['order'], 
217              # needed when users do bogus things like editing config files 
218              # manually (branch setting) 
219              self.SystemSettings['repositories']['branch'], 
220          ))) 
221