src/pakfire/packages/solv.py

   1 #!/usr/bin/python
   2 ###############################################################################
   3 #                                                                             #
   4 # Pakfire - The IPFire package management system                              #
   5 # Copyright (C) 2011 Pakfire development team                                 #
   6 #                                                                             #
   7 # This program is free software: you can redistribute it and/or modify        #
   8 # it under the terms of the GNU General Public License as published by        #
   9 # the Free Software Foundation, either version 3 of the License, or           #
  10 # (at your option) any later version.                                         #
  11 #                                                                             #
  12 # This program is distributed in the hope that it will be useful,             #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  15 # GNU General Public License for more details.                                #
  16 #                                                                             #
  17 # You should have received a copy of the GNU General Public License           #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21
  22 import os
  23 import re
  24
  25 import base
  26 import file
  27
  28 class SolvPackage(base.Package):
  29         def __init__(self, pakfire, solvable, repo=None):
  30                 base.Package.__init__(self, pakfire, repo)
  31
  32                 # Save solvable object
  33                 self.solvable = solvable
  34
  35                 self.__evr = None
  36
  37         @property
  38         def uuid(self):
  39                 return self.solvable.get_uuid()
  40
  41         @property
  42         def hash1(self):
  43                 return self.solvable.get_hash1()
  44
  45         @property
  46         def name(self):
  47                 return self.solvable.get_name()
  48
  49         @property
  50         def evr(self):
  51                 if self.__evr is None:
  52                         m = re.match("^([0-9]+\:)?([0-9A-Za-z\.\-_]+)-([0-9]+\.?[a-z0-9\.\-\_]+|[0-9]+)$",
  53                                 self.solvable.get_evr())
  54
  55                         if m:
  56                                 (e, v, r) = m.groups()
  57
  58                                 if e:
  59                                         e = e.replace(":", "")
  60                                         e = int(e)
  61
  62                                 self.__evr = (e, v, r)
  63
  64                 assert self.__evr
  65                 return self.__evr
  66
  67         @property
  68         def epoch(self):
  69                 return self.evr[0]
  70
  71         @property
  72         def version(self):
  73                 return self.evr[1]
  74
  75         @property
  76         def release(self):
  77                 return self.evr[2]
  78
  79         @property
  80         def arch(self):
  81                 return self.solvable.get_arch()
  82
  83         @property
  84         def repo(self):
  85                 if self._repo:
  86                         return self._repo
  87
  88                 repo_name = self.solvable.get_repo_name()
  89                 return self.pakfire.repos.get_repo(repo_name)
  90
  91         @property
  92         def summary(self):
  93                 return self.solvable.get_summary()
  94
  95         @property
  96         def description(self):
  97                 return self.solvable.get_description() or ""
  98
  99         @property
 100         def groups(self):
 101                 groups = self.solvable.get_groups()
 102
 103                 if groups:
 104                         return groups.split()
 105
 106                 return []
 107
 108         @property
 109         def license(self):
 110                 return self.solvable.get_license()
 111
 112         @property
 113         def maintainer(self):
 114                 return self.solvable.get_maintainer()
 115
 116         @property
 117         def url(self):
 118                 return self.solvable.get_url()
 119
 120         @property
 121         def size(self):
 122                 return self.solvable.get_downloadsize()
 123
 124         @property
 125         def inst_size(self):
 126                 return self.solvable.get_installsize()
 127
 128         @property
 129         def vendor(self):
 130                 vendor = self.solvable.get_vendor()
 131
 132                 if vendor == "<NULL>":
 133                         return None
 134
 135                 return vendor
 136
 137         @property
 138         def build_host(self):
 139                 return self.solvable.get_buildhost()
 140
 141         @property
 142         def build_time(self):
 143                 return self.solvable.get_buildtime()
 144
 145         @property
 146         def build_id(self):
 147                 return "XXX CURRENTLY NOT IMPLEMENTED"
 148
 149         @property
 150         def provides(self):
 151                 return self.solvable.get_provides()
 152
 153         @property
 154         def _requires(self):
 155                 requires = self.solvable.get_requires()
 156
 157                 try:
 158                         i = requires.index("solvable:prereqmarker")
 159
 160                         return (requires[i+1:], requires[:i],)
 161                 except ValueError:
 162                         return ([], requires,)
 163
 164         @property
 165         def prerequires(self):
 166                 prereqs, reqs = self._requires
 167
 168                 return prereqs
 169
 170         @property
 171         def requires(self):
 172                 prereqs, reqs = self._requires
 173
 174                 return reqs
 175
 176         @property
 177         def obsoletes(self):
 178                 return self.solvable.get_obsoletes()
 179
 180         @property
 181         def conflicts(self):
 182                 return self.solvable.get_conflicts()
 183
 184         @property
 185         def recommends(self):
 186                 return self.solvable.get_recommends()
 187
 188         @property
 189         def suggests(self):
 190                 return self.solvable.get_suggests()
 191
 192         @property
 193         def filename(self):
 194                 return self.solvable.get_filename()
 195
 196         @property
 197         def filelist(self):
 198                 # XXX need to support filelist.
 199                 return ["%s does not support filelists, yet." % self.__class__.__name__,]
 200
 201         @property
 202         def cache_filename(self):
 203                 """
 204                         The path to this file in the cache.
 205                 """
 206                 h = self.hash1
 207
 208                 return os.path.join(h[0:2], h[2:], os.path.basename(self.filename))
 209
 210         @property
 211         def is_in_cache(self):
 212                 # Local files are always kinda cached.
 213                 if self.repo.local:
 214                         return True
 215
 216                 # If the repository has got a cache, we check if the file
 217                 # is in there.
 218                 if self.repo.cache:
 219                         return self.repo.cache.exists(self.cache_filename)
 220
 221                 return False
 222
 223         def get_from_cache(self):
 224                 path = None
 225
 226                 if self.repo.local:
 227                         # Search for a file in the local repository. It can be either in
 228                         # the root directory of the repository or in a subdirectory that
 229                         # is named by the architecture.
 230                         for i in ("", self.arch,):
 231                                 p = os.path.join(self.repo.path, i, self.filename)
 232
 233                                 if os.path.exists(p):
 234                                         path = p
 235                                         break
 236
 237                         return file.BinaryPackage(self.pakfire, self.repo, path)
 238
 239                 if not self.repo.cache:
 240                         return
 241
 242                 if self.repo.cache.exists(self.cache_filename):
 243                         # Check if the checksum matches, too.
 244                         if not self.repo.cache.verify(self.cache_filename, self.hash1):
 245                                 return
 246
 247                         path = self.repo.cache.abspath(self.cache_filename)
 248                         return file.BinaryPackage(self.pakfire, self.repo, path)
 249
 250         def get_from_db(self):
 251                 return self.pakfire.repos.local.get_package_by_uuid(self.uuid)
 252
 253         def download(self, text="", logger=None):
 254                 if not self.repo.local:
 255                         self.repo.download(self, text=text, logger=logger)
 256
 257                 return self.get_from_cache()