dak/admin.py

   1 #!/usr/bin/env python
   2
   3 """Configure dak parameters in the database"""
   4 # Copyright (C) 2009  Mark Hymers <mhy@debian.org>
   5
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 ################################################################################
  21
  22 import sys
  23
  24 import apt_pkg
  25
  26 from daklib import utils
  27 from daklib.dbconn import *
  28 from sqlalchemy.orm.exc import NoResultFound
  29
  30 ################################################################################
  31
  32 dispatch = {}
  33 dryrun = False
  34
  35 ################################################################################
  36 def warn(msg):
  37     print >> sys.stderr, msg
  38
  39 def die(msg, exit_code=1):
  40     print >> sys.stderr, msg
  41     sys.exit(exit_code)
  42
  43 def die_arglen(args, args_needed, msg):
  44     if len(args) < args_needed:
  45         die(msg)
  46
  47 def usage(exit_code=0):
  48     """Perform administrative work on the dak database."""
  49
  50     print """Usage: dak admin COMMAND
  51 Perform administrative work on the dak database.
  52
  53   -h, --help          show this help and exit.
  54   -n, --dry-run       don't do anything, just show what would have been done
  55                       (only applies to add or rm operations).
  56
  57   Commands can use a long or abbreviated form:
  58
  59   config / c:
  60      c db                   show db config
  61      c db-shell             show db config in a usable form for psql
  62      c NAME                 show option NAME as set in configuration table
  63
  64   keyring / k:
  65      k list-all             list all keyrings
  66      k list-binary          list all keyrings with a NULL source acl
  67      k list-source          list all keyrings with a non NULL source acl
  68
  69   architecture / a:
  70      a list                 show a list of architectures
  71      a rm ARCH              remove an architecture (will only work if
  72                             no longer linked to any suites)
  73      a add ARCH DESCRIPTION [SUITELIST]
  74                             add architecture ARCH with DESCRIPTION.
  75                             If SUITELIST is given, add to each of the
  76                             suites at the same time
  77
  78   suite / s:
  79      s list                 show a list of suites
  80      s show SUITE           show config details for a suite
  81      s add SUITE VERSION [ label=LABEL ] [ description=DESCRIPTION ]
  82                          [ origin=ORIGIN ] [ codename=CODENAME ]
  83                          [ signingkey=SIGNINGKEY ]
  84                             add suite SUITE, version VERSION.
  85                             label, description, origin, codename
  86                             and signingkey are optional.
  87
  88      s add-all-arches SUITE VERSION... as "s add" but adds suite-architecture
  89                             relationships for all architectures
  90
  91   suite-architecture / s-a:
  92      s-a list               show the architectures for all suites
  93      s-a list-suite ARCH    show the suites an ARCH is in
  94      s-a list-arch SUITE    show the architectures in a SUITE
  95      s-a add SUITE ARCH     add ARCH to suite
  96      s-a rm SUITE ARCH      remove ARCH from suite (will only work if
  97                             no packages remain for the arch in the suite)
  98
  99   version-check / v-c:
 100      v-c list                        show version checks for all suites
 101      v-c list-suite SUITE            show version checks for suite SUITE
 102      v-c add SUITE CHECK REFERENCE   add a version check for suite SUITE
 103      v-c rm SUITE CHECK REFERENCE    remove a version check
 104        where
 105          CHECK     is one of Enhances, MustBeNewerThan, MustBeOlderThan
 106          REFERENCE is another suite name
 107 """
 108     sys.exit(exit_code)
 109
 110 ################################################################################
 111
 112 def __architecture_list(d, args):
 113     q = d.session().query(Architecture).order_by('arch_string')
 114     for j in q.all():
 115         # HACK: We should get rid of source from the arch table
 116         if j.arch_string == 'source': continue
 117         print j.arch_string
 118     sys.exit(0)
 119
 120 def __architecture_add(d, args):
 121     die_arglen(args, 4, "E: adding an architecture requires a name and a description")
 122     print "Adding architecture %s" % args[2]
 123     suites = [str(x) for x in args[4:]]
 124     if len(suites) > 0:
 125         print "Adding to suites %s" % ", ".join(suites)
 126     if not dryrun:
 127         try:
 128             s = d.session()
 129             a = Architecture()
 130             a.arch_string = str(args[2]).lower()
 131             a.description = str(args[3])
 132             s.add(a)
 133             for sn in suites:
 134                 su = get_suite(sn, s)
 135                 if su is not None:
 136                     a.suites.append(su)
 137                 else:
 138                     warn("W: Cannot find suite %s" % su)
 139             s.commit()
 140         except IntegrityError as e:
 141             die("E: Integrity error adding architecture %s (it probably already exists)" % args[2])
 142         except SQLAlchemyError as e:
 143             die("E: Error adding architecture %s (%s)" % (args[2], e))
 144     print "Architecture %s added" % (args[2])
 145
 146 def __architecture_rm(d, args):
 147     die_arglen(args, 3, "E: removing an architecture requires at least a name")
 148     print "Removing architecture %s" % args[2]
 149     if not dryrun:
 150         try:
 151             s = d.session()
 152             a = get_architecture(args[2].lower(), s)
 153             if a is None:
 154                 die("E: Cannot find architecture %s" % args[2])
 155             s.delete(a)
 156             s.commit()
 157         except IntegrityError as e:
 158             die("E: Integrity error removing architecture %s (suite-arch entries probably still exist)" % args[2])
 159         except SQLAlchemyError as e:
 160             die("E: Error removing architecture %s (%s)" % (args[2], e))
 161     print "Architecture %s removed" % args[2]
 162
 163 def architecture(command):
 164     args = [str(x) for x in command]
 165     Cnf = utils.get_conf()
 166     d = DBConn()
 167
 168     die_arglen(args, 2, "E: architecture needs at least a command")
 169
 170     mode = args[1].lower()
 171     if mode == 'list':
 172         __architecture_list(d, args)
 173     elif mode == 'add':
 174         __architecture_add(d, args)
 175     elif mode == 'rm':
 176         __architecture_rm(d, args)
 177     else:
 178         die("E: architecture command unknown")
 179
 180 dispatch['architecture'] = architecture
 181 dispatch['a'] = architecture
 182
 183 ################################################################################
 184
 185 def __suite_list(d, args):
 186     s = d.session()
 187     for j in s.query(Suite).order_by('suite_name').all():
 188         print j.suite_name
 189
 190 def __suite_show(d, args):
 191     if len(args) < 2:
 192         die("E: showing an suite entry requires a suite")
 193
 194     s = d.session()
 195     su = get_suite(args[2].lower())
 196     if su is None:
 197         die("E: can't find suite entry for %s" % (args[2].lower()))
 198
 199     print su.details()
 200
 201 def __suite_add(d, args, addallarches=False):
 202     die_arglen(args, 4, "E: adding a suite requires at least a name and a version")
 203     suite_name = args[2].lower()
 204     version = args[3]
 205     rest = args[3:]
 206
 207     def get_field(field):
 208         for varval in args:
 209             if varval.startswith(field + '='):
 210                 return varval.split('=')[1]
 211         return None
 212
 213     print "Adding suite %s" % suite_name
 214     if not dryrun:
 215         try:
 216             s = d.session()
 217             suite = Suite()
 218             suite.suite_name = suite_name
 219             suite.overridecodename = suite_name
 220             suite.version = version
 221             suite.label = get_field('label')
 222             suite.description = get_field('description')
 223             suite.origin = get_field('origin')
 224             suite.codename = get_field('codename')
 225             signingkey = get_field('signingkey')
 226             if signingkey is not None:
 227                 suite.signingkeys = [signingkey.upper()]
 228             suite.srcformats = s.query(SrcFormat).all()
 229             s.add(suite)
 230             s.flush()
 231         except IntegrityError as e:
 232             die("E: Integrity error adding suite %s (it probably already exists)" % suite_name)
 233         except SQLAlchemyError as e:
 234             die("E: Error adding suite %s (%s)" % (suite_name, e))
 235     print "Suite %s added" % (suite_name)
 236
 237     if addallarches:
 238         arches = []
 239         q = s.query(Architecture).order_by('arch_string')
 240         for arch in q.all():
 241             suite.architectures.append(arch)
 242             arches.append(arch.arch_string)
 243
 244         print "Architectures %s added to %s" % (','.join(arches), suite_name)
 245
 246     s.commit()
 247
 248
 249 def suite(command):
 250     args = [str(x) for x in command]
 251     Cnf = utils.get_conf()
 252     d = DBConn()
 253
 254     die_arglen(args, 2, "E: suite needs at least a command")
 255
 256     mode = args[1].lower()
 257
 258     if mode == 'list':
 259         __suite_list(d, args)
 260     elif mode == 'show':
 261         __suite_show(d, args)
 262     elif mode == 'add':
 263         __suite_add(d, args, False)
 264     elif mode == 'add-all-arches':
 265         __suite_add(d, args, True)
 266     else:
 267         die("E: suite command unknown")
 268
 269 dispatch['suite'] = suite
 270 dispatch['s'] = suite
 271
 272 ################################################################################
 273
 274 def __suite_architecture_list(d, args):
 275     s = d.session()
 276     for j in s.query(Suite).order_by('suite_name'):
 277         architectures = j.get_architectures(skipsrc = True, skipall = True)
 278         print j.suite_name + ': ' + \
 279               ', '.join([a.arch_string for a in architectures])
 280
 281 def __suite_architecture_listarch(d, args):
 282     die_arglen(args, 3, "E: suite-architecture list-arch requires a suite")
 283     suite = get_suite(args[2].lower(), d.session())
 284     if suite is None:
 285         die('E: suite %s is invalid' % args[2].lower())
 286     a = suite.get_architectures(skipsrc = True, skipall = True)
 287     for j in a:
 288         print j.arch_string
 289
 290
 291 def __suite_architecture_listsuite(d, args):
 292     die_arglen(args, 3, "E: suite-architecture list-suite requires an arch")
 293     architecture = get_architecture(args[2].lower(), d.session())
 294     if architecture is None:
 295         die("E: architecture %s is invalid" % args[2].lower())
 296     for j in architecture.suites:
 297         print j.suite_name
 298
 299
 300 def __suite_architecture_add(d, args):
 301     if len(args) < 3:
 302         die("E: adding a suite-architecture entry requires a suite and arch")
 303
 304     s = d.session()
 305
 306     suite = get_suite(args[2].lower(), s)
 307     if suite is None: die("E: Can't find suite %s" % args[2].lower())
 308
 309     arch = get_architecture(args[3].lower(), s)
 310     if arch is None: die("E: Can't find architecture %s" % args[3].lower())
 311
 312     if not dryrun:
 313         try:
 314             suite.architectures.append(arch)
 315             s.commit()
 316         except IntegrityError as e:
 317             die("E: Can't add suite-architecture entry (%s, %s) - probably already exists" % (args[2].lower(), args[3].lower()))
 318         except SQLAlchemyError as e:
 319             die("E: Can't add suite-architecture entry (%s, %s) - %s" % (args[2].lower(), args[3].lower(), e))
 320
 321     print "Added suite-architecture entry for %s, %s" % (args[2].lower(), args[3].lower())
 322
 323
 324 def __suite_architecture_rm(d, args):
 325     if len(args) < 3:
 326         die("E: removing an suite-architecture entry requires a suite and arch")
 327
 328     s = d.session()
 329     if not dryrun:
 330         try:
 331             suite_name = args[2].lower()
 332             suite = get_suite(suite_name, s)
 333             if suite is None:
 334                 die('E: no such suite %s' % suite_name)
 335             arch_string = args[3].lower()
 336             architecture = get_architecture(arch_string, s)
 337             if architecture not in suite.architectures:
 338                 die("E: architecture %s not found in suite %s" % (arch_string, suite_name))
 339             suite.architectures.remove(architecture)
 340             s.commit()
 341         except IntegrityError as e:
 342             die("E: Can't remove suite-architecture entry (%s, %s) - it's probably referenced" % (args[2].lower(), args[3].lower()))
 343         except SQLAlchemyError as e:
 344             die("E: Can't remove suite-architecture entry (%s, %s) - %s" % (args[2].lower(), args[3].lower(), e))
 345
 346     print "Removed suite-architecture entry for %s, %s" % (args[2].lower(), args[3].lower())
 347
 348
 349 def suite_architecture(command):
 350     args = [str(x) for x in command]
 351     Cnf = utils.get_conf()
 352     d = DBConn()
 353
 354     die_arglen(args, 2, "E: suite-architecture needs at least a command")
 355
 356     mode = args[1].lower()
 357
 358     if mode == 'list':
 359         __suite_architecture_list(d, args)
 360     elif mode == 'list-arch':
 361         __suite_architecture_listarch(d, args)
 362     elif mode == 'list-suite':
 363         __suite_architecture_listsuite(d, args)
 364     elif mode == 'add':
 365         __suite_architecture_add(d, args)
 366     elif mode == 'rm':
 367         __suite_architecture_rm(d, args)
 368     else:
 369         die("E: suite-architecture command unknown")
 370
 371 dispatch['suite-architecture'] = suite_architecture
 372 dispatch['s-a'] = suite_architecture
 373
 374 ################################################################################
 375
 376 def __version_check_list(d):
 377     session = d.session()
 378     for s in session.query(Suite).order_by('suite_name'):
 379         __version_check_list_suite(d, s.suite_name)
 380
 381 def __version_check_list_suite(d, suite_name):
 382     vcs = get_version_checks(suite_name)
 383     for vc in vcs:
 384         print "%s %s %s" % (suite_name, vc.check, vc.reference.suite_name)
 385
 386 def __version_check_add(d, suite_name, check, reference_name):
 387     suite = get_suite(suite_name)
 388     if not suite:
 389         die("E: Could not find suite %s." % (suite_name))
 390     reference = get_suite(reference_name)
 391     if not reference:
 392         die("E: Could not find reference suite %s." % (reference_name))
 393
 394     session = d.session()
 395     vc = VersionCheck()
 396     vc.suite = suite
 397     vc.check = check
 398     vc.reference = reference
 399     session.add(vc)
 400     session.commit()
 401
 402 def __version_check_rm(d, suite_name, check, reference_name):
 403     suite = get_suite(suite_name)
 404     if not suite:
 405         die("E: Could not find suite %s." % (suite_name))
 406     reference = get_suite(reference_name)
 407     if not reference:
 408         die("E: Could not find reference suite %s." % (reference_name))
 409
 410     session = d.session()
 411     try:
 412       vc = session.query(VersionCheck).filter_by(suite=suite, check=check, reference=reference).one()
 413       session.delete(vc)
 414       session.commit()
 415     except NoResultFound:
 416       print "W: version-check not found."
 417
 418 def version_check(command):
 419     args = [str(x) for x in command]
 420     Cnf = utils.get_conf()
 421     d = DBConn()
 422
 423     die_arglen(args, 2, "E: version-check needs at least a command")
 424     mode = args[1].lower()
 425
 426     if mode == 'list':
 427         __version_check_list(d)
 428     elif mode == 'list-suite':
 429         if len(args) != 3:
 430             die("E: version-check list-suite needs a single parameter")
 431         __version_check_list_suite(d, args[2])
 432     elif mode == 'add':
 433         if len(args) != 5:
 434             die("E: version-check add needs three parameters")
 435         __version_check_add(d, args[2], args[3], args[4])
 436     elif mode == 'rm':
 437         if len(args) != 5:
 438             die("E: version-check rm needs three parameters")
 439         __version_check_rm(d, args[2], args[3], args[4])
 440     else:
 441         die("E: version-check command unknown")
 442
 443 dispatch['version-check'] = version_check
 444 dispatch['v-c'] = version_check
 445
 446 ################################################################################
 447
 448 def show_config(command):
 449     args = [str(x) for x in command]
 450     cnf = utils.get_conf()
 451
 452     die_arglen(args, 2, "E: config needs at least a command")
 453
 454     mode = args[1].lower()
 455
 456     if mode == 'db':
 457         connstr = ""
 458         if cnf.has_key("DB::Service"):
 459             # Service mode
 460             connstr = "postgresql://service=%s" % cnf["DB::Service"]
 461         elif cnf.has_key("DB::Host"):
 462             # TCP/IP
 463             connstr = "postgres://%s" % cnf["DB::Host"]
 464             if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
 465                 connstr += ":%s" % cnf["DB::Port"]
 466             connstr += "/%s" % cnf["DB::Name"]
 467         else:
 468             # Unix Socket
 469             connstr = "postgres:///%s" % cnf["DB::Name"]
 470             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
 471                 connstr += "?port=%s" % cnf["DB::Port"]
 472         print connstr
 473     elif mode == 'db-shell':
 474         e = []
 475         if cnf.has_key("DB::Service"):
 476             e.append('PGSERVICE')
 477             print "PGSERVICE=%s" % cnf["DB::Service"]
 478         if cnf.has_key("DB::Name"):
 479             e.append('PGDATABASE')
 480             print "PGDATABASE=%s" % cnf["DB::Name"]
 481         if cnf.has_key("DB::Host"):
 482             print "PGHOST=%s" % cnf["DB::Host"]
 483             e.append('PGHOST')
 484         if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
 485             print "PGPORT=%s" % cnf["DB::Port"]
 486             e.append('PGPORT')
 487         print "export " + " ".join(e)
 488     else:
 489         session = DBConn().session()
 490         try:
 491             o = session.query(DBConfig).filter_by(name = mode).one()
 492             print o.value
 493         except NoResultFound:
 494             print "W: option '%s' not set" % mode
 495
 496 dispatch['config'] = show_config
 497 dispatch['c'] = show_config
 498
 499 ################################################################################
 500
 501 def show_keyring(command):
 502     args = [str(x) for x in command]
 503     cnf = utils.get_conf()
 504
 505     die_arglen(args, 2, "E: keyring needs at least a command")
 506
 507     mode = args[1].lower()
 508
 509     d = DBConn()
 510
 511     q = d.session().query(Keyring).filter(Keyring.active == True)
 512
 513     if mode == 'list-all':
 514         pass
 515     elif mode == 'list-binary':
 516         q = q.filter(Keyring.default_source_acl_id == None)
 517     elif mode == 'list-source':
 518         q = q.filter(Keyring.default_source_acl_id != None)
 519     else:
 520         die("E: keyring command unknown")
 521
 522     for k in q.all():
 523         print k.keyring_name
 524
 525 dispatch['keyring'] = show_keyring
 526 dispatch['k'] = show_keyring
 527
 528 ################################################################################
 529
 530 def main():
 531     """Perform administrative work on the dak database"""
 532     global dryrun
 533     Cnf = utils.get_conf()
 534     arguments = [('h', "help", "Admin::Options::Help"),
 535                  ('n', "dry-run", "Admin::Options::Dry-Run")]
 536     for i in [ "help", "dry-run" ]:
 537         if not Cnf.has_key("Admin::Options::%s" % (i)):
 538             Cnf["Admin::Options::%s" % (i)] = ""
 539
 540     arguments = apt_pkg.ParseCommandLine(Cnf, arguments, sys.argv)
 541
 542     options = Cnf.SubTree("Admin::Options")
 543     if options["Help"] or len(arguments) < 1:
 544         usage()
 545     if options["Dry-Run"]:
 546         dryrun = True
 547
 548     subcommand = str(arguments[0])
 549
 550     if subcommand in dispatch.keys():
 551         dispatch[subcommand](arguments)
 552     else:
 553         die("E: Unknown command")
 554
 555 ################################################################################
 556
 557 if __name__ == '__main__':
 558     main()