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