src/buildservice/distribution.py

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