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   archive:
 100      archive list           list all archives
 101      archive add NAME ROOT DESCRIPTION [primary-mirror=MIRROR] [tainted=1]
 102                             add archive NAME with path ROOT,
 103                             primary mirror MIRROR.
 104      archive rm NAME        remove archive NAME (will only work if there are
 105                             no files and no suites in the archive)
 106
 107   version-check / v-c:
 108      v-c list                        show version checks for all suites
 109      v-c list-suite SUITE            show version checks for suite SUITE
 110      v-c add SUITE CHECK REFERENCE   add a version check for suite SUITE
 111      v-c rm SUITE CHECK REFERENCE    remove a version check
 112        where
 113          CHECK     is one of Enhances, MustBeNewerThan, MustBeOlderThan
 114          REFERENCE is another suite name
 115 """
 116     sys.exit(exit_code)
 117
 118 ################################################################################
 119
 120 def __architecture_list(d, args):
 121     q = d.session().query(Architecture).order_by(Architecture.arch_string)
 122     for j in q.all():
 123         # HACK: We should get rid of source from the arch table
 124         if j.arch_string == 'source': continue
 125         print j.arch_string
 126     sys.exit(0)
 127
 128 def __architecture_add(d, args):
 129     die_arglen(args, 4, "E: adding an architecture requires a name and a description")
 130     print "Adding architecture %s" % args[2]
 131     suites = [str(x) for x in args[4:]]
 132     if len(suites) > 0:
 133         print "Adding to suites %s" % ", ".join(suites)
 134     if not dryrun:
 135         try:
 136             s = d.session()
 137             a = Architecture()
 138             a.arch_string = str(args[2]).lower()
 139             a.description = str(args[3])
 140             s.add(a)
 141             for sn in suites:
 142                 su = get_suite(sn, s)
 143                 if su is not None:
 144                     a.suites.append(su)
 145                 else:
 146                     warn("W: Cannot find suite %s" % su)
 147             s.commit()
 148         except IntegrityError as e:
 149             die("E: Integrity error adding architecture %s (it probably already exists)" % args[2])
 150         except SQLAlchemyError as e:
 151             die("E: Error adding architecture %s (%s)" % (args[2], e))
 152     print "Architecture %s added" % (args[2])
 153
 154 def __architecture_rm(d, args):
 155     die_arglen(args, 3, "E: removing an architecture requires at least a name")
 156     print "Removing architecture %s" % args[2]
 157     if not dryrun:
 158         try:
 159             s = d.session()
 160             a = get_architecture(args[2].lower(), s)
 161             if a is None:
 162                 die("E: Cannot find architecture %s" % args[2])
 163             s.delete(a)
 164             s.commit()
 165         except IntegrityError as e:
 166             die("E: Integrity error removing architecture %s (suite-arch entries probably still exist)" % args[2])
 167         except SQLAlchemyError as e:
 168             die("E: Error removing architecture %s (%s)" % (args[2], e))
 169     print "Architecture %s removed" % args[2]
 170
 171 def architecture(command):
 172     args = [str(x) for x in command]
 173     Cnf = utils.get_conf()
 174     d = DBConn()
 175
 176     die_arglen(args, 2, "E: architecture needs at least a command")
 177
 178     mode = args[1].lower()
 179     if mode == 'list':
 180         __architecture_list(d, args)
 181     elif mode == 'add':
 182         __architecture_add(d, args)
 183     elif mode == 'rm':
 184         __architecture_rm(d, args)
 185     else:
 186         die("E: architecture command unknown")
 187
 188 dispatch['architecture'] = architecture
 189 dispatch['a'] = architecture
 190
 191 ################################################################################
 192
 193 def __suite_list(d, args):
 194     s = d.session()
 195     for j in s.query(Suite).order_by(Suite.suite_name).all():
 196         print j.suite_name
 197
 198 def __suite_show(d, args):
 199     if len(args) < 2:
 200         die("E: showing an suite entry requires a suite")
 201
 202     s = d.session()
 203     su = get_suite(args[2].lower())
 204     if su is None:
 205         die("E: can't find suite entry for %s" % (args[2].lower()))
 206
 207     print su.details()
 208
 209 def __suite_add(d, args, addallarches=False):
 210     die_arglen(args, 4, "E: adding a suite requires at least a name and a version")
 211     suite_name = args[2].lower()
 212     version = args[3]
 213     rest = args[3:]
 214
 215     def get_field(field):
 216         for varval in args:
 217             if varval.startswith(field + '='):
 218                 return varval.split('=')[1]
 219         return None
 220
 221     print "Adding suite %s" % suite_name
 222     if not dryrun:
 223         try:
 224             s = d.session()
 225             suite = Suite()
 226             suite.suite_name = suite_name
 227             suite.overridecodename = suite_name
 228             suite.version = version
 229             suite.label = get_field('label')
 230             suite.description = get_field('description')
 231             suite.origin = get_field('origin')
 232             suite.codename = get_field('codename')
 233             signingkey = get_field('signingkey')
 234             if signingkey is not None:
 235                 suite.signingkeys = [signingkey.upper()]
 236             archive_name = get_field('archive')
 237             if archive_name is not None:
 238                 suite.archive = get_archive(archive_name, s)
 239             else:
 240                 suite.archive = s.query(Archive).filter(~Archive.archive_name.in_(['build-queues', 'new', 'policy'])).one()
 241             suite.srcformats = s.query(SrcFormat).all()
 242             s.add(suite)
 243             s.flush()
 244         except IntegrityError as e:
 245             die("E: Integrity error adding suite %s (it probably already exists)" % suite_name)
 246         except SQLAlchemyError as e:
 247             die("E: Error adding suite %s (%s)" % (suite_name, e))
 248     print "Suite %s added" % (suite_name)
 249
 250     if addallarches:
 251         arches = []
 252         q = s.query(Architecture).order_by(Architecture.arch_string)
 253         for arch in q.all():
 254             suite.architectures.append(arch)
 255             arches.append(arch.arch_string)
 256
 257         print "Architectures %s added to %s" % (','.join(arches), suite_name)
 258
 259     s.commit()
 260
 261
 262 def suite(command):
 263     args = [str(x) for x in command]
 264     Cnf = utils.get_conf()
 265     d = DBConn()
 266
 267     die_arglen(args, 2, "E: suite needs at least a command")
 268
 269     mode = args[1].lower()
 270
 271     if mode == 'list':
 272         __suite_list(d, args)
 273     elif mode == 'show':
 274         __suite_show(d, args)
 275     elif mode == 'add':
 276         __suite_add(d, args, False)
 277     elif mode == 'add-all-arches':
 278         __suite_add(d, args, True)
 279     else:
 280         die("E: suite command unknown")
 281
 282 dispatch['suite'] = suite
 283 dispatch['s'] = suite
 284
 285 ################################################################################
 286
 287 def __suite_architecture_list(d, args):
 288     s = d.session()
 289     for j in s.query(Suite).order_by(Suite.suite_name):
 290         architectures = j.get_architectures(skipsrc = True, skipall = True)
 291         print j.suite_name + ': ' + \
 292               ', '.join([a.arch_string for a in architectures])
 293
 294 def __suite_architecture_listarch(d, args):
 295     die_arglen(args, 3, "E: suite-architecture list-arch requires a suite")
 296     suite = get_suite(args[2].lower(), d.session())
 297     if suite is None:
 298         die('E: suite %s is invalid' % args[2].lower())
 299     a = suite.get_architectures(skipsrc = True, skipall = True)
 300     for j in a:
 301         print j.arch_string
 302
 303
 304 def __suite_architecture_listsuite(d, args):
 305     die_arglen(args, 3, "E: suite-architecture list-suite requires an arch")
 306     architecture = get_architecture(args[2].lower(), d.session())
 307     if architecture is None:
 308         die("E: architecture %s is invalid" % args[2].lower())
 309     for j in architecture.suites:
 310         print j.suite_name
 311
 312
 313 def __suite_architecture_add(d, args):
 314     if len(args) < 3:
 315         die("E: adding a suite-architecture entry requires a suite and arch")
 316
 317     s = d.session()
 318
 319     suite = get_suite(args[2].lower(), s)
 320     if suite is None: die("E: Can't find suite %s" % args[2].lower())
 321
 322     arch = get_architecture(args[3].lower(), s)
 323     if arch is None: die("E: Can't find architecture %s" % args[3].lower())
 324
 325     if not dryrun:
 326         try:
 327             suite.architectures.append(arch)
 328             s.commit()
 329         except IntegrityError as e:
 330             die("E: Can't add suite-architecture entry (%s, %s) - probably already exists" % (args[2].lower(), args[3].lower()))
 331         except SQLAlchemyError as e:
 332             die("E: Can't add suite-architecture entry (%s, %s) - %s" % (args[2].lower(), args[3].lower(), e))
 333
 334     print "Added suite-architecture entry for %s, %s" % (args[2].lower(), args[3].lower())
 335
 336
 337 def __suite_architecture_rm(d, args):
 338     if len(args) < 3:
 339         die("E: removing an suite-architecture entry requires a suite and arch")
 340
 341     s = d.session()
 342     if not dryrun:
 343         try:
 344             suite_name = args[2].lower()
 345             suite = get_suite(suite_name, s)
 346             if suite is None:
 347                 die('E: no such suite %s' % suite_name)
 348             arch_string = args[3].lower()
 349             architecture = get_architecture(arch_string, s)
 350             if architecture not in suite.architectures:
 351                 die("E: architecture %s not found in suite %s" % (arch_string, suite_name))
 352             suite.architectures.remove(architecture)
 353             s.commit()
 354         except IntegrityError as e:
 355             die("E: Can't remove suite-architecture entry (%s, %s) - it's probably referenced" % (args[2].lower(), args[3].lower()))
 356         except SQLAlchemyError as e:
 357             die("E: Can't remove suite-architecture entry (%s, %s) - %s" % (args[2].lower(), args[3].lower(), e))
 358
 359     print "Removed suite-architecture entry for %s, %s" % (args[2].lower(), args[3].lower())
 360
 361
 362 def suite_architecture(command):
 363     args = [str(x) for x in command]
 364     Cnf = utils.get_conf()
 365     d = DBConn()
 366
 367     die_arglen(args, 2, "E: suite-architecture needs at least a command")
 368
 369     mode = args[1].lower()
 370
 371     if mode == 'list':
 372         __suite_architecture_list(d, args)
 373     elif mode == 'list-arch':
 374         __suite_architecture_listarch(d, args)
 375     elif mode == 'list-suite':
 376         __suite_architecture_listsuite(d, args)
 377     elif mode == 'add':
 378         __suite_architecture_add(d, args)
 379     elif mode == 'rm':
 380         __suite_architecture_rm(d, args)
 381     else:
 382         die("E: suite-architecture command unknown")
 383
 384 dispatch['suite-architecture'] = suite_architecture
 385 dispatch['s-a'] = suite_architecture
 386
 387 ################################################################################
 388
 389 def archive_list():
 390     session = DBConn().session()
 391     for archive in session.query(Archive).order_by(Archive.archive_name):
 392         print "{0} path={1} description={2} tainted={3}".format(archive.archive_name, archive.path, archive.description, archive.tainted)
 393
 394 def archive_add(args):
 395     (name, path, description) = args[0:3]
 396
 397     attributes = dict(
 398         archive_name=name,
 399         path=path,
 400         description=description,
 401         )
 402
 403     for option in args[3:]:
 404         (key, value) = option.split('=')
 405         attributes[key] = value
 406
 407     session = DBConn().session()
 408
 409     archive = Archive()
 410     for key, value in attributes.iteritems():
 411         setattr(archive, key, value)
 412
 413     session.add(archive)
 414     session.flush()
 415
 416     if dryrun:
 417         session.rollback()
 418     else:
 419         session.commit()
 420
 421 def archive_rm(name):
 422     session = DBConn().session()
 423     archive = session.query(Archive).filter_by(archive_name=name).one()
 424     session.delete(archive)
 425     session.flush()
 426
 427     if dryrun:
 428         session.rollback()
 429     else:
 430         session.commit()
 431
 432 def archive(command):
 433     mode = command[1]
 434     if mode == 'list':
 435         archive_list()
 436     elif mode == 'add':
 437         archive_add(command[2:])
 438     elif mode == 'rm':
 439         archive_rm(command[2])
 440     else:
 441         die("E: archive command unknown")
 442
 443 dispatch['archive'] = archive
 444
 445 ################################################################################
 446
 447 def __version_check_list(d):
 448     session = d.session()
 449     for s in session.query(Suite).order_by(Suite.suite_name):
 450         __version_check_list_suite(d, s.suite_name)
 451
 452 def __version_check_list_suite(d, suite_name):
 453     vcs = get_version_checks(suite_name)
 454     for vc in vcs:
 455         print "%s %s %s" % (suite_name, vc.check, vc.reference.suite_name)
 456
 457 def __version_check_add(d, suite_name, check, reference_name):
 458     suite = get_suite(suite_name)
 459     if not suite:
 460         die("E: Could not find suite %s." % (suite_name))
 461     reference = get_suite(reference_name)
 462     if not reference:
 463         die("E: Could not find reference suite %s." % (reference_name))
 464
 465     session = d.session()
 466     vc = VersionCheck()
 467     vc.suite = suite
 468     vc.check = check
 469     vc.reference = reference
 470     session.add(vc)
 471     session.commit()
 472
 473 def __version_check_rm(d, suite_name, check, reference_name):
 474     suite = get_suite(suite_name)
 475     if not suite:
 476         die("E: Could not find suite %s." % (suite_name))
 477     reference = get_suite(reference_name)
 478     if not reference:
 479         die("E: Could not find reference suite %s." % (reference_name))
 480
 481     session = d.session()
 482     try:
 483       vc = session.query(VersionCheck).filter_by(suite=suite, check=check, reference=reference).one()
 484       session.delete(vc)
 485       session.commit()
 486     except NoResultFound:
 487       print "W: version-check not found."
 488
 489 def version_check(command):
 490     args = [str(x) for x in command]
 491     Cnf = utils.get_conf()
 492     d = DBConn()
 493
 494     die_arglen(args, 2, "E: version-check needs at least a command")
 495     mode = args[1].lower()
 496
 497     if mode == 'list':
 498         __version_check_list(d)
 499     elif mode == 'list-suite':
 500         if len(args) != 3:
 501             die("E: version-check list-suite needs a single parameter")
 502         __version_check_list_suite(d, args[2])
 503     elif mode == 'add':
 504         if len(args) != 5:
 505             die("E: version-check add needs three parameters")
 506         __version_check_add(d, args[2], args[3], args[4])
 507     elif mode == 'rm':
 508         if len(args) != 5:
 509             die("E: version-check rm needs three parameters")
 510         __version_check_rm(d, args[2], args[3], args[4])
 511     else:
 512         die("E: version-check command unknown")
 513
 514 dispatch['version-check'] = version_check
 515 dispatch['v-c'] = version_check
 516
 517 ################################################################################
 518
 519 def show_config(command):
 520     args = [str(x) for x in command]
 521     cnf = utils.get_conf()
 522
 523     die_arglen(args, 2, "E: config needs at least a command")
 524
 525     mode = args[1].lower()
 526
 527     if mode == 'db':
 528         connstr = ""
 529         if cnf.has_key("DB::Service"):
 530             # Service mode
 531             connstr = "postgresql://service=%s" % cnf["DB::Service"]
 532         elif cnf.has_key("DB::Host"):
 533             # TCP/IP
 534             connstr = "postgres://%s" % cnf["DB::Host"]
 535             if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
 536                 connstr += ":%s" % cnf["DB::Port"]
 537             connstr += "/%s" % cnf["DB::Name"]
 538         else:
 539             # Unix Socket
 540             connstr = "postgres:///%s" % cnf["DB::Name"]
 541             if cnf["DB::Port"] and cnf["DB::Port"] != "-1":
 542                 connstr += "?port=%s" % cnf["DB::Port"]
 543         print connstr
 544     elif mode == 'db-shell':
 545         e = []
 546         if cnf.has_key("DB::Service"):
 547             e.append('PGSERVICE')
 548             print "PGSERVICE=%s" % cnf["DB::Service"]
 549         if cnf.has_key("DB::Name"):
 550             e.append('PGDATABASE')
 551             print "PGDATABASE=%s" % cnf["DB::Name"]
 552         if cnf.has_key("DB::Host"):
 553             print "PGHOST=%s" % cnf["DB::Host"]
 554             e.append('PGHOST')
 555         if cnf.has_key("DB::Port") and cnf["DB::Port"] != "-1":
 556             print "PGPORT=%s" % cnf["DB::Port"]
 557             e.append('PGPORT')
 558         print "export " + " ".join(e)
 559     else:
 560         session = DBConn().session()
 561         try:
 562             o = session.query(DBConfig).filter_by(name = mode).one()
 563             print o.value
 564         except NoResultFound:
 565             print "W: option '%s' not set" % mode
 566
 567 dispatch['config'] = show_config
 568 dispatch['c'] = show_config
 569
 570 ################################################################################
 571
 572 def show_keyring(command):
 573     args = [str(x) for x in command]
 574     cnf = utils.get_conf()
 575
 576     die_arglen(args, 2, "E: keyring needs at least a command")
 577
 578     mode = args[1].lower()
 579
 580     d = DBConn()
 581
 582     q = d.session().query(Keyring).filter(Keyring.active == True)
 583
 584     if mode == 'list-all':
 585         pass
 586     elif mode == 'list-binary':
 587         q = q.filter(Keyring.default_source_acl_id == None)
 588     elif mode == 'list-source':
 589         q = q.filter(Keyring.default_source_acl_id != None)
 590     else:
 591         die("E: keyring command unknown")
 592
 593     for k in q.all():
 594         print k.keyring_name
 595
 596 dispatch['keyring'] = show_keyring
 597 dispatch['k'] = show_keyring
 598
 599 ################################################################################
 600
 601 def main():
 602     """Perform administrative work on the dak database"""
 603     global dryrun
 604     Cnf = utils.get_conf()
 605     arguments = [('h', "help", "Admin::Options::Help"),
 606                  ('n', "dry-run", "Admin::Options::Dry-Run")]
 607     for i in [ "help", "dry-run" ]:
 608         if not Cnf.has_key("Admin::Options::%s" % (i)):
 609             Cnf["Admin::Options::%s" % (i)] = ""
 610
 611     arguments = apt_pkg.parse_commandline(Cnf, arguments, sys.argv)
 612
 613     options = Cnf.subtree("Admin::Options")
 614     if options["Help"] or len(arguments) < 1:
 615         usage()
 616     if options["Dry-Run"]:
 617         dryrun = True
 618
 619     subcommand = str(arguments[0])
 620
 621     if subcommand in dispatch.keys():
 622         dispatch[subcommand](arguments)
 623     else:
 624         die("E: Unknown command")
 625
 626 ################################################################################
 627
 628 if __name__ == '__main__':
 629     main()