src/buildservice/distribution.py

   1 #!/usr/bin/python
   2
   3 import logging
   4
   5 import arches
   6 import base
   7 import builds
   8 import packages
   9 import sources
  10 import updates
  11
  12 from repository import Repository, RepositoryAux
  13
  14 class Distributions(base.Object):
  15         def get_all(self):
  16                 distros = self.db.query("SELECT * FROM distributions ORDER BY name")
  17
  18                 return [Distribution(self.pakfire, d.id, d) for d in distros]
  19
  20         def get_by_id(self, id):
  21                 distro = self.db.get("SELECT * FROM distributions WHERE id = %s LIMIT 1", id)
  22
  23                 if distro:
  24                         return Distribution(self.pakfire, distro.id, distro)
  25
  26         def get_by_name(self, name):
  27                 distro = self.db.get("SELECT * FROM distributions WHERE sname = %s LIMIT 1", name)
  28
  29                 if distro:
  30                         return Distribution(self.pakfire, distro.id, distro)
  31
  32         def get_by_ident(self, ident):
  33                 return self.get_by_name(ident)
  34
  35         def get_default(self):
  36                 # XXX a bit ugly
  37                 return self.get_by_ident("ipfire3")
  38
  39
  40 class Distribution(base.Object):
  41         def __init__(self, pakfire, id, data=None):
  42                 base.Object.__init__(self, pakfire)
  43                 self.id = id
  44
  45                 self._data = data
  46                 self._arches = None
  47                 self._sources = None
  48
  49         def __repr__(self):
  50                 return "<%s %s>" % (self.__class__.__name__, self.name)
  51
  52         @property
  53         def data(self):
  54                 if self._data is None:
  55                         self._data = self.db.get("SELECT * FROM distributions WHERE id = %s", self.id)
  56
  57                 return self._data
  58
  59         def set(self, key, value):
  60                 self.db.execute("UPDATE distributions SET %s = %%s WHERE id = %%s" % key,
  61                         value, self.id)
  62
  63                 if self._data:
  64                         self._data[key] = value
  65
  66         @property
  67         def info(self):
  68                 return {
  69                         "name"        : self.name,
  70                         "sname"       : self.sname,
  71                         "slogan"      : self.slogan,
  72                         "vendor"      : self.vendor,
  73                         "contact"     : self.contact,
  74                         "description" : self.description,
  75                 }
  76
  77         def get_config(self):
  78                 try:
  79                         name, release = self.name.split()
  80                 except:
  81                         name = self.name
  82                         release = "N/A"
  83
  84                 lines = [
  85                         "[distro]",
  86                         "name = %s" % name,
  87                         "release = %s" % release,
  88                         "slogan = %s" % self.slogan,
  89                         "",
  90                         "vendor = %s" % self.vendor,
  91                         "contact = %s" % self.contact,
  92                 ]
  93
  94                 return "\n".join(lines)
  95
  96         @property
  97         def name(self):
  98                 return self.data.name
  99
 100         @property
 101         def sname(self):
 102                 return self.data.sname
 103
 104         @property
 105         def identifier(self):
 106                 return self.sname
 107
 108         @property
 109         def slogan(self):
 110                 return self.data.slogan
 111
 112         def get_arches(self):
 113                 if self._arches is None:
 114                         _arches = self.db.query("SELECT arch_id AS id FROM distro_arches \
 115                                 WHERE distro_id = %s", self.id)
 116
 117                         self._arches = []
 118                         for arch in _arches:
 119                                 arch = arches.Arch(self.pakfire, arch.id)
 120                                 self._arches.append(arch)
 121
 122                         # Sort architectures by their priority.
 123                         self._arches.sort()
 124
 125                 return self._arches
 126
 127         def set_arches(self, _arches):
 128                 self.db.execute("DELETE FROM distro_arches WHERE distro_id = %s", self.id)
 129
 130                 for arch in _arches:
 131                         self.db.execute("INSERT INTO distro_arches(distro_id, arch_id) \
 132                                 VALUES(%s, %s)", self.id, arch.id)
 133
 134                 self._arches = _arches
 135
 136         arches = property(get_arches, set_arches)
 137
 138         @property
 139         def vendor(self):
 140                 return self.data.vendor
 141
 142         def get_contact(self):
 143                 return self.data.contact
 144
 145         def set_contact(self, contact):
 146                 self.db.execute("UPDATE distributions SET contact = %s WHERE id = %s",
 147                         contact, self.id)
 148
 149                 if self._data:
 150                         self._data["contact"] = contact
 151
 152         contact = property(get_contact, set_contact)
 153
 154         def get_tag(self):
 155                 return self.data.tag
 156
 157         def set_tag(self, tag):
 158                 self.db.execute("UPDATE distributions SET tag = %s WHERE id = %s",
 159                         tag, self.id)
 160
 161                 if self._data:
 162                         self._data["tag"] = tag
 163
 164         tag = property(get_tag, set_tag)
 165
 166         @property
 167         def description(self):
 168                 return self.data.description or ""
 169
 170         @property
 171         def repositories(self):
 172                 _repos = self.db.query("SELECT id FROM repositories WHERE distro_id = %s", self.id)
 173
 174                 repos = []
 175                 for repo in _repos:
 176                         repo = Repository(self.pakfire, repo.id)
 177                         repo._distro = self
 178
 179                         repos.append(repo)
 180
 181                 return sorted(repos)
 182
 183         @property
 184         def repositories_aux(self):
 185                 _repos = self.db.query("SELECT id FROM repositories_aux \
 186                         WHERE status = 'enabled' AND distro_id = %s", self.id)
 187
 188                 repos = []
 189                 for repo in _repos:
 190                         repo = RepositoryAux(self.pakfire, repo.id)
 191                         repo._distro = self
 192
 193                         repos.append(repo)
 194
 195                 return sorted(repos)
 196
 197         def get_repo(self, name):
 198                 repo = self.db.get("SELECT id FROM repositories WHERE distro_id = %s AND name = %s",
 199                         self.id, name)
 200
 201                 if not repo:
 202                         return
 203
 204                 repo = Repository(self.pakfire, repo.id)
 205                 repo._distro = self
 206
 207                 return repo
 208
 209         def get_build_repos(self):
 210                 repos = []
 211
 212                 for repo in self.repositories:
 213                         if repo.enabled_for_builds:
 214                                 repos.append(repo)
 215
 216                 # Add all aux. repositories.
 217                 repos += self.repositories_aux
 218
 219                 return repos
 220
 221         @property
 222         def first_repo(self):
 223                 repos = self.repositories
 224
 225                 if repos:
 226                         return self.repositories[-1]
 227
 228         @property
 229         def comprehensive_repositories(self):
 230                 return [r for r in self.repositories if r.comprehensive]
 231
 232         def add_repository(self, name, description):
 233                 return Repository.new(self.pakfire, self, name, description)
 234
 235         @property
 236         def log(self):
 237                 return [] # TODO
 238
 239         def has_package(self, name, epoch, version, release):
 240                 #pkg = self.db.get("SELECT packages.id AS id FROM packages \
 241                 #       JOIN builds ON packages.id = builds.pkg_id \
 242                 #       JOIN sources_commits ON packages.commit_id = sources_commits.id \
 243                 #       JOIN sources ON sources_commits.source_id = sources.id \
 244                 #       WHERE builds.type = 'release' AND sources.distro_id = %s \
 245                 #       AND packages.name = %s AND packages.epoch = %s \
 246                 #       AND packages.version = %s AND packages.release = %s LIMIT 1",
 247                 #       self.id, name, epoch, version, release)
 248
 249                 pkg = self.db.get("SELECT p.id AS id FROM packages p \
 250                         JOIN builds b ON p.id = b.pkg_id \
 251                         WHERE b.type = 'release' AND b.distro_id = %s AND \
 252                         p.name = %s AND p.epoch = %s AND p.version = %s AND p.release = %s \
 253                         LIMIT 1", self.id, name, epoch, version, release)
 254
 255                 if not pkg:
 256                         logging.debug("Package %s-%s:%s-%s does not exist, yet." % \
 257                                 (name, epoch, version, release))
 258                         return
 259
 260                 logging.debug("Package %s-%s:%s-%s does already exist." % \
 261                         (name, epoch, version, release))
 262
 263                 return packages.Package(self.pakfire, pkg.id)
 264
 265         def delete_package(self, name):
 266                 pass # XXX figure out what to do at this place
 267
 268         @property
 269         def sources(self):
 270                 if self._sources is None:
 271                         self._sources = []
 272
 273                         for source in self.db.query("SELECT id FROM sources WHERE distro_id = %s", self.id):
 274                                 source = sources.Source(self.pakfire, source.id)
 275                                 self._sources.append(source)
 276
 277                         self._sources.sort()
 278
 279                 return self._sources
 280
 281         def get_source(self, ident):
 282                 for source in self.sources:
 283                         if not source.identifier == ident:
 284                                 continue
 285
 286                         return source