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         def __iter__(self):
  57                 return iter(self.repositories)
  58
  59         @property
  60         def info(self):
  61                 return {
  62                         "name"        : self.name,
  63                         "sname"       : self.sname,
  64                         "slogan"      : self.slogan,
  65                         "vendor"      : self.vendor,
  66                         "contact"     : self.contact,
  67                         "description" : self.description,
  68                 }
  69
  70         def get_config(self):
  71                 try:
  72                         name, release = self.name.split()
  73                 except:
  74                         name = self.name
  75                         release = "N/A"
  76
  77                 lines = [
  78                         "[distro]",
  79                         "name = %s" % name,
  80                         "release = %s" % release,
  81                         "slogan = %s" % self.slogan,
  82                         "",
  83                         "vendor = %s" % self.vendor,
  84                         "contact = %s" % self.contact,
  85                 ]
  86
  87                 return "\n".join(lines)
  88
  89         @property
  90         def name(self):
  91                 return self.data.name
  92
  93         @property
  94         def sname(self):
  95                 return self.data.sname
  96
  97         @property
  98         def identifier(self):
  99                 return self.sname
 100
 101         @property
 102         def slogan(self):
 103                 return self.data.slogan
 104
 105         def get_arches(self):
 106                 res = self.db.query("SELECT arch FROM distributions_arches \
 107                         WHERE distro_id = %s ORDER BY arch", self.id)
 108
 109                 return sorted((row.arch for row in res), key=arches.priority)
 110
 111         def set_arches(self, arches):
 112                 self.db.execute("DELETE FROM distro_arches WHERE distro_id = %s", self.id)
 113
 114                 for arch in arches:
 115                         self.db.execute("INSERT INTO distro_arches(distro_id, arch) \
 116                                 VALUES(%s, %s)", self.id, arch)
 117
 118                 self.arches = sorted(arches)
 119
 120         arches = lazy_property(get_arches, set_arches)
 121
 122         @property
 123         def vendor(self):
 124                 return self.data.vendor
 125
 126         def get_contact(self):
 127                 return self.data.contact
 128
 129         def set_contact(self, contact):
 130                 self._set_attribute("contact", contact)
 131
 132         contact = property(get_contact, set_contact)
 133
 134         def get_tag(self):
 135                 return self.data.tag
 136
 137         def set_tag(self, tag):
 138                 self._set_attribute("tag", tag)
 139
 140         tag = property(get_tag, set_tag)
 141
 142         @property
 143         def description(self):
 144                 return self.data.description or ""
 145
 146         @lazy_property
 147         def repositories(self):
 148                 _repositories = self.backend.repos._get_repositories("SELECT * FROM repositories \
 149                         WHERE distro_id = %s", self.id)
 150
 151                 # Cache
 152                 repositories = []
 153                 for repo in _repositories:
 154                         repo.distro = self
 155                         repositories.append(repo)
 156
 157                 return sorted(repositories)
 158
 159         @lazy_property
 160         def repositories_aux(self):
 161                 _repos = self.db.query("SELECT id FROM repositories_aux \
 162                         WHERE status = 'enabled' AND distro_id = %s", self.id)
 163
 164                 repos = []
 165                 for repo in _repos:
 166                         repo = RepositoryAux(self.pakfire, repo.id)
 167                         repo._distro = self
 168
 169                         repos.append(repo)
 170
 171                 return sorted(repos)
 172
 173         def get_repo(self, name):
 174                 repo = self.backend.repos._get_repository("SELECT * FROM repositories \
 175                         WHERE distro_id = %s AND name = %s", self.id, name)
 176
 177                 # Cache
 178                 repo.distro = self
 179
 180                 return repo
 181
 182         def get_build_repos(self):
 183                 repos = []
 184
 185                 for repo in self.repositories:
 186                         if repo.enabled_for_builds:
 187                                 repos.append(repo)
 188
 189                 # Add all aux. repositories.
 190                 repos += self.repositories_aux
 191
 192                 return repos
 193
 194         @property
 195         def first_repo(self):
 196                 repos = self.repositories
 197
 198                 if repos:
 199                         return self.repositories[-1]
 200
 201         @property
 202         def log(self):
 203                 return [] # TODO
 204
 205         def has_package(self, name, epoch, version, release):
 206                 #pkg = self.db.get("SELECT packages.id AS id FROM packages \
 207                 #       JOIN builds ON packages.id = builds.pkg_id \
 208                 #       JOIN sources_commits ON packages.commit_id = sources_commits.id \
 209                 #       JOIN sources ON sources_commits.source_id = sources.id \
 210                 #       WHERE builds.type = 'release' AND sources.distro_id = %s \
 211                 #       AND packages.name = %s AND packages.epoch = %s \
 212                 #       AND packages.version = %s AND packages.release = %s LIMIT 1",
 213                 #       self.id, name, epoch, version, release)
 214
 215                 pkg = self.db.get("SELECT p.id AS id FROM packages p \
 216                         JOIN builds b ON p.id = b.pkg_id \
 217                         WHERE b.type = 'release' AND b.distro_id = %s AND \
 218                         p.name = %s AND p.epoch = %s AND p.version = %s AND p.release = %s \
 219                         LIMIT 1", self.id, name, epoch, version, release)
 220
 221                 if not pkg:
 222                         logging.debug("Package %s-%s:%s-%s does not exist, yet." % \
 223                                 (name, epoch, version, release))
 224                         return
 225
 226                 logging.debug("Package %s-%s:%s-%s does already exist." % \
 227                         (name, epoch, version, release))
 228
 229                 return packages.Package(self.pakfire, pkg.id)
 230
 231         def delete_package(self, name):
 232                 pass # XXX figure out what to do at this place
 233
 234         @lazy_property
 235         def sources(self):
 236                 _sources = []
 237
 238                 for source in self.db.query("SELECT id FROM sources WHERE distro_id = %s", self.id):
 239                         source = sources.Source(self.pakfire, source.id)
 240                         _sources.append(source)
 241
 242                 return sorted(_sources)
 243
 244         def get_source(self, identifier):
 245                 for source in self.sources:
 246                         if not source.identifier == identifier:
 247                                 continue
 248
 249                         return source