python/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 vendor(self):
 126                 vendor = self.solvable.get_vendor()
 127
 128                 if vendor == "<NULL>":
 129                         return None
 130
 131                 return vendor
 132
 133         @property
 134         def uuid(self):
 135                 return self.solvable.get_uuid()
 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], 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 filename(self):
 186                 return self.solvable.get_filename()
 187
 188         @property
 189         def filelist(self):
 190                 # XXX need to support filelist.
 191                 return ["%s does not support filelists, yet." % self.__class__.__name__,]
 192
 193         @property
 194         def is_in_cache(self):
 195                 # Local files are always kinda cached.
 196                 if self.repo.local:
 197                         return True
 198
 199                 return self.repo.cache.exists("package/%s" % self.filename)
 200
 201         def get_from_cache(self):
 202                 path = None
 203
 204                 if self.repo.local:
 205                         # Search for a file in the local repository. It can be either in
 206                         # the root directory of the repository or in a subdirectory that
 207                         # is named by the architecture.
 208                         for i in ("", self.arch,):
 209                                 path = os.path.join(self.repo.path, i, self.filename)
 210
 211                                 if os.path.exists(path):
 212                                         return file.BinaryPackage(self.pakfire, self.repo, path)
 213                 else:
 214                         filename = "packages/%s" % self.filename
 215
 216                         if self.repo.cache.exists(filename):
 217                                 path = self.repo.cache.abspath(filename)
 218
 219                 if path:
 220                         return file.BinaryPackage(self.pakfire, self.repo, path)
 221
 222         def download(self, text=""):
 223                 if not self.repo.local:
 224                         self.repo.download(self, text=text)
 225
 226                 return self.get_from_cache()
 227
 228         def get_scriptlet(self, type):
 229                 # XXX TODO
 230                 return None