pakfire/packages/installed.py

   1 #!/usr/bin/python
   2
   3 import os
   4
   5 import pakfire.downloader
   6
   7 from base import Package
   8 from binary import BinaryPackage
   9
  10 from pakfire.constants import *
  11
  12 class DatabasePackage(Package):
  13         type = "db"
  14
  15         def __init__(self, pakfire, repo, db, data):
  16                 Package.__init__(self, pakfire, repo)
  17
  18                 self.db = db
  19
  20                 self._data = {}
  21
  22                 for key in data.keys():
  23                         self._data[key] = data[key]
  24
  25         def __repr__(self):
  26                 return "<%s %s>" % (self.__class__.__name__, self.friendly_name)
  27
  28         @property
  29         def metadata(self):
  30                 return self._data
  31
  32         @property
  33         def id(self):
  34                 id = self.metadata.get("id")
  35                 if not id:
  36                         id = 0
  37
  38                 return id
  39
  40         @property
  41         def name(self):
  42                 return self.metadata.get("name")
  43
  44         @property
  45         def version(self):
  46                 return self.metadata.get("version")
  47
  48         @property
  49         def release(self):
  50                 return self.metadata.get("release")
  51
  52         @property
  53         def epoch(self):
  54                 epoch = self.metadata.get("epoch", 0)
  55
  56                 return int(epoch)
  57
  58         @property
  59         def arch(self):
  60                 return self.metadata.get("arch")
  61
  62         @property
  63         def maintainer(self):
  64                 return self.metadata.get("maintainer")
  65
  66         @property
  67         def license(self):
  68                 return self.metadata.get("license")
  69
  70         @property
  71         def summary(self):
  72                 return self.metadata.get("summary")
  73
  74         @property
  75         def description(self):
  76                 return self.metadata.get("description")
  77
  78         @property
  79         def groups(self):
  80                 return self.metadata.get("groups", "").split()
  81
  82         @property
  83         def build_date(self):
  84                 return self.metadata.get("build_date")
  85
  86         @property
  87         def build_time(self):
  88                 build_time = self.metadata.get("build_time", 0)
  89
  90                 try:
  91                         return int(build_time)
  92                 except TypeError:
  93                         return 0
  94
  95         @property
  96         def build_host(self):
  97                 return self.metadata.get("build_host")
  98
  99         @property
 100         def build_id(self):
 101                 return self.metadata.get("build_id")
 102
 103         @property
 104         def uuid(self):
 105                 return self.metadata.get("uuid")
 106
 107         @property
 108         def size(self):
 109                 return self.metadata.get("size", 0)
 110
 111         @property
 112         def provides(self):
 113                 return self.metadata.get("provides", "").split()
 114
 115         @property
 116         def requires(self):
 117                 return self.metadata.get("requires", "").split()
 118
 119         @property
 120         def conflicts(self):
 121                 return self.metadata.get("conflicts", "").split()
 122
 123         @property
 124         def obsoletes(self):
 125                 return self.metadata.get("obsoletes", "").split()
 126
 127         @property
 128         def hash1(self):
 129                 return self.metadata.get("hash1")
 130
 131         @property
 132         def scriptlet(self):
 133                 return self.metadata.get("scriptlet")
 134
 135         @property
 136         def filename(self):
 137                 return self.metadata.get("filename") # XXX basename?
 138
 139         @property
 140         def filelist(self):
 141                 c = self.db.cursor()
 142                 try:
 143                         c.execute("SELECT name FROM files WHERE pkg = ?", (self.id,))
 144
 145                         return [f["name"] for f in c]
 146                 finally:
 147                         c.close()
 148
 149         def _does_provide_file(self, requires):
 150                 """
 151                         A faster version to find a file in the database.
 152                 """
 153                 c = self.db.cursor()
 154                 c.execute("SELECT * FROM files WHERE name GLOB ? AND pkg = ?",
 155                         (requires.requires, self.id))
 156
 157                 ret = False
 158                 for pkg in c:
 159                         ret = True
 160                         break
 161
 162                 c.close()
 163
 164                 return ret
 165
 166         def download(self, text=""):
 167                 """
 168                         Downloads the package from repository and returns a new instance
 169                         of BinaryPackage.
 170                 """
 171
 172                 # XXX a bit hacky, but InstalledRepository has no cache.
 173                 if self.repo.name == "installed":
 174                         return self
 175
 176                 # Marker, if we need to download the package.
 177                 download = True
 178
 179                 # Add shortcut for cache.
 180                 cache = self.repo.cache
 181
 182                 cache_filename = "packages/%s" % os.path.basename(self.filename)
 183
 184                 # Check if file already exists in cache.
 185                 if cache.exists(cache_filename):
 186                         # If the file does already exist, we check if the hash1 matches.
 187                         if cache.verify(cache_filename, self.hash1):
 188                                 # We already got the right file. Skip download.
 189                                 download = False
 190                         else:
 191                                 # The file in cache has a wrong hash. Remove it and repeat download.
 192                                 cache.remove(cache_filename)
 193
 194                 if download:
 195                         # Make sure filename is of type string (and not unicode)
 196                         filename = str(self.filename)
 197
 198                         # Get a package grabber and add mirror download capabilities to it.
 199                         grabber = pakfire.downloader.PackageDownloader(
 200                                 text=text + os.path.basename(filename),
 201                         )
 202                         grabber = self.repo.mirrors.group(grabber)
 203
 204                         i = grabber.urlopen(filename)
 205
 206                         # Open input and output files and download the file.
 207                         o = cache.open(cache_filename, "w")
 208
 209                         buf = i.read(BUFFER_SIZE)
 210                         while buf:
 211                                 o.write(buf)
 212                                 buf = i.read(BUFFER_SIZE)
 213
 214                         i.close()
 215                         o.close()
 216
 217                         # Verify if the download was okay.
 218                         if not cache.verify(cache_filename, self.hash1):
 219                                 raise Exception, "XXX this should never happen..."
 220
 221                 filename = os.path.join(cache.path, cache_filename)
 222                 return BinaryPackage(self.pakfire, self.repo, filename)
 223
 224 # XXX maybe we can remove this later?
 225 class InstalledPackage(DatabasePackage):
 226         type = "installed"
 227