]> git.decadent.org.uk Git - dak.git/blob - dak/admin.py
Merge remote-tracking branch 'drkranz/misc' into merge
[dak.git] / 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()