roundup/admin.py

   1 #! /usr/bin/env python
   2 #
   3 # Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
   4 # This module is free software, and you may redistribute it and/or modify
   5 # under the same terms as Python, so long as this copyright message and
   6 # disclaimer are retained in their original form.
   7 #
   8 # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
   9 # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
  10 # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
  11 # POSSIBILITY OF SUCH DAMAGE.
  12 #
  13 # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  14 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  15 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
  16 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
  17 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  18 #
  19 # $Id: admin.py,v 1.20 2002-08-01 00:56:22 richard Exp $
  20
  21 import sys, os, getpass, getopt, re, UserDict, shlex, shutil
  22 try:
  23     import csv
  24 except ImportError:
  25     csv = None
  26 from roundup import date, hyperdb, roundupdb, init, password, token
  27 from roundup import __version__ as roundup_version
  28 import roundup.instance
  29 from roundup.i18n import _
  30
  31 class CommandDict(UserDict.UserDict):
  32     '''Simple dictionary that lets us do lookups using partial keys.
  33
  34     Original code submitted by Engelbert Gruber.
  35     '''
  36     _marker = []
  37     def get(self, key, default=_marker):
  38         if self.data.has_key(key):
  39             return [(key, self.data[key])]
  40         keylist = self.data.keys()
  41         keylist.sort()
  42         l = []
  43         for ki in keylist:
  44             if ki.startswith(key):
  45                 l.append((ki, self.data[ki]))
  46         if not l and default is self._marker:
  47             raise KeyError, key
  48         return l
  49
  50 class UsageError(ValueError):
  51     pass
  52
  53 class AdminTool:
  54
  55     def __init__(self):
  56         self.commands = CommandDict()
  57         for k in AdminTool.__dict__.keys():
  58             if k[:3] == 'do_':
  59                 self.commands[k[3:]] = getattr(self, k)
  60         self.help = {}
  61         for k in AdminTool.__dict__.keys():
  62             if k[:5] == 'help_':
  63                 self.help[k[5:]] = getattr(self, k)
  64         self.instance_home = ''
  65         self.db = None
  66
  67     def get_class(self, classname):
  68         '''Get the class - raise an exception if it doesn't exist.
  69         '''
  70         try:
  71             return self.db.getclass(classname)
  72         except KeyError:
  73             raise UsageError, _('no such class "%(classname)s"')%locals()
  74
  75     def props_from_args(self, args):
  76         props = {}
  77         for arg in args:
  78             if arg.find('=') == -1:
  79                 raise UsageError, _('argument "%(arg)s" not propname=value')%locals()
  80             try:
  81                 key, value = arg.split('=')
  82             except ValueError:
  83                 raise UsageError, _('argument "%(arg)s" not propname=value')%locals()
  84             props[key] = value
  85         return props
  86
  87     def usage(self, message=''):
  88         if message:
  89             message = _('Problem: %(message)s)\n\n')%locals()
  90         print _('''%(message)sUsage: roundup-admin [-i instance home] [-u login] [-c] <command> <arguments>
  91
  92 Help:
  93  roundup-admin -h
  94  roundup-admin help                       -- this help
  95  roundup-admin help <command>             -- command-specific help
  96  roundup-admin help all                   -- all available help
  97 Options:
  98  -i instance home  -- specify the issue tracker "home directory" to administer
  99  -u                -- the user[:password] to use for commands
 100  -c                -- when outputting lists of data, just comma-separate them''')%locals()
 101         self.help_commands()
 102
 103     def help_commands(self):
 104         print _('Commands:'),
 105         commands = ['']
 106         for command in self.commands.values():
 107             h = command.__doc__.split('\n')[0]
 108             commands.append(' '+h[7:])
 109         commands.sort()
 110         commands.append(_('Commands may be abbreviated as long as the abbreviation matches only one'))
 111         commands.append(_('command, e.g. l == li == lis == list.'))
 112         print '\n'.join(commands)
 113         print
 114
 115     def help_commands_html(self, indent_re=re.compile(r'^(\s+)\S+')):
 116         commands = self.commands.values()
 117         def sortfun(a, b):
 118             return cmp(a.__name__, b.__name__)
 119         commands.sort(sortfun)
 120         for command in commands:
 121             h = command.__doc__.split('\n')
 122             name = command.__name__[3:]
 123             usage = h[0]
 124             print _('''
 125 <tr><td valign=top><strong>%(name)s</strong></td>
 126     <td><tt>%(usage)s</tt><p>
 127 <pre>''')%locals()
 128             indent = indent_re.match(h[3])
 129             if indent: indent = len(indent.group(1))
 130             for line in h[3:]:
 131                 if indent:
 132                     print line[indent:]
 133                 else:
 134                     print line
 135             print _('</pre></td></tr>\n')
 136
 137     def help_all(self):
 138         print _('''
 139 All commands (except help) require an instance specifier. This is just the path
 140 to the roundup instance you're working with. A roundup instance is where
 141 roundup keeps the database and configuration file that defines an issue
 142 tracker. It may be thought of as the issue tracker's "home directory". It may
 143 be specified in the environment variable ROUNDUP_INSTANCE or on the command
 144 line as "-i instance".
 145
 146 A designator is a classname and a nodeid concatenated, eg. bug1, user10, ...
 147
 148 Property values are represented as strings in command arguments and in the
 149 printed results:
 150  . Strings are, well, strings.
 151  . Date values are printed in the full date format in the local time zone, and
 152    accepted in the full format or any of the partial formats explained below.
 153  . Link values are printed as node designators. When given as an argument,
 154    node designators and key strings are both accepted.
 155  . Multilink values are printed as lists of node designators joined by commas.
 156    When given as an argument, node designators and key strings are both
 157    accepted; an empty string, a single node, or a list of nodes joined by
 158    commas is accepted.
 159
 160 When property values must contain spaces, just surround the value with
 161 quotes, either ' or ". A single space may also be backslash-quoted. If a
 162 valuu must contain a quote character, it must be backslash-quoted or inside
 163 quotes. Examples:
 164            hello world      (2 tokens: hello, world)
 165            "hello world"    (1 token: hello world)
 166            "Roch'e" Compaan (2 tokens: Roch'e Compaan)
 167            Roch\'e Compaan  (2 tokens: Roch'e Compaan)
 168            address="1 2 3"  (1 token: address=1 2 3)
 169            \\               (1 token: \)
 170            \n\r\t           (1 token: a newline, carriage-return and tab)
 171
 172 When multiple nodes are specified to the roundup get or roundup set
 173 commands, the specified properties are retrieved or set on all the listed
 174 nodes.
 175
 176 When multiple results are returned by the roundup get or roundup find
 177 commands, they are printed one per line (default) or joined by commas (with
 178 the -c) option.
 179
 180 Where the command changes data, a login name/password is required. The
 181 login may be specified as either "name" or "name:password".
 182  . ROUNDUP_LOGIN environment variable
 183  . the -u command-line option
 184 If either the name or password is not supplied, they are obtained from the
 185 command-line.
 186
 187 Date format examples:
 188   "2000-04-17.03:45" means <Date 2000-04-17.08:45:00>
 189   "2000-04-17" means <Date 2000-04-17.00:00:00>
 190   "01-25" means <Date yyyy-01-25.00:00:00>
 191   "08-13.22:13" means <Date yyyy-08-14.03:13:00>
 192   "11-07.09:32:43" means <Date yyyy-11-07.14:32:43>
 193   "14:25" means <Date yyyy-mm-dd.19:25:00>
 194   "8:47:11" means <Date yyyy-mm-dd.13:47:11>
 195   "." means "right now"
 196
 197 Command help:
 198 ''')
 199         for name, command in self.commands.items():
 200             print _('%s:')%name
 201             print _('   '), command.__doc__
 202
 203     def do_help(self, args, nl_re=re.compile('[\r\n]'),
 204             indent_re=re.compile(r'^(\s+)\S+')):
 205         '''Usage: help topic
 206         Give help about topic.
 207
 208         commands  -- list commands
 209         <command> -- help specific to a command
 210         initopts  -- init command options
 211         all       -- all available help
 212         '''
 213         if len(args)>0:
 214             topic = args[0]
 215         else:
 216             topic = 'help'
 217
 218
 219         # try help_ methods
 220         if self.help.has_key(topic):
 221             self.help[topic]()
 222             return 0
 223
 224         # try command docstrings
 225         try:
 226             l = self.commands.get(topic)
 227         except KeyError:
 228             print _('Sorry, no help for "%(topic)s"')%locals()
 229             return 1
 230
 231         # display the help for each match, removing the docsring indent
 232         for name, help in l:
 233             lines = nl_re.split(help.__doc__)
 234             print lines[0]
 235             indent = indent_re.match(lines[1])
 236             if indent: indent = len(indent.group(1))
 237             for line in lines[1:]:
 238                 if indent:
 239                     print line[indent:]
 240                 else:
 241                     print line
 242         return 0
 243
 244     def help_initopts(self):
 245         import roundup.templates
 246         templates = roundup.templates.listTemplates()
 247         print _('Templates:'), ', '.join(templates)
 248         import roundup.backends
 249         backends = roundup.backends.__all__
 250         print _('Back ends:'), ', '.join(backends)
 251
 252     def do_install(self, instance_home, args):
 253         '''Usage: install [template [backend [admin password]]]
 254         Install a new Roundup instance.
 255
 256         The command will prompt for the instance home directory (if not supplied
 257         through INSTANCE_HOME or the -i option). The template, backend and admin
 258         password may be specified on the command-line as arguments, in that
 259         order.
 260
 261         The initialise command must be called after this command in order
 262         to initialise the instance's database. You may edit the instance's
 263         initial database contents before running that command by editing
 264         the instance's dbinit.py module init() function.
 265
 266         See also initopts help.
 267         '''
 268         if len(args) < 1:
 269             raise UsageError, _('Not enough arguments supplied')
 270
 271         # make sure the instance home can be created
 272         parent = os.path.split(instance_home)[0]
 273         if not os.path.exists(parent):
 274             raise UsageError, _('Instance home parent directory "%(parent)s"'
 275                 ' does not exist')%locals()
 276
 277         # select template
 278         import roundup.templates
 279         templates = roundup.templates.listTemplates()
 280         template = len(args) > 1 and args[1] or ''
 281         if template not in templates:
 282             print _('Templates:'), ', '.join(templates)
 283         while template not in templates:
 284             template = raw_input(_('Select template [classic]: ')).strip()
 285             if not template:
 286                 template = 'classic'
 287
 288         # select hyperdb backend
 289         import roundup.backends
 290         backends = roundup.backends.__all__
 291         backend = len(args) > 2 and args[2] or ''
 292         if backend not in backends:
 293             print _('Back ends:'), ', '.join(backends)
 294         while backend not in backends:
 295             backend = raw_input(_('Select backend [anydbm]: ')).strip()
 296             if not backend:
 297                 backend = 'anydbm'
 298
 299         # install!
 300         init.install(instance_home, template, backend)
 301
 302         print _('''
 303  You should now edit the instance configuration file:
 304    %(instance_config_file)s
 305  ... at a minimum, you must set MAILHOST, MAIL_DOMAIN and ADMIN_EMAIL.
 306
 307  If you wish to modify the default schema, you should also edit the database
 308  initialisation file:
 309    %(database_config_file)s
 310  ... see the documentation on customizing for more information.
 311 ''')%{
 312     'instance_config_file': os.path.join(instance_home, 'instance_config.py'),
 313     'database_config_file': os.path.join(instance_home, 'dbinit.py')
 314 }
 315         return 0
 316
 317
 318     def do_initialise(self, instance_home, args):
 319         '''Usage: initialise [adminpw]
 320         Initialise a new Roundup instance.
 321
 322         The administrator details will be set at this step.
 323
 324         Execute the instance's initialisation function dbinit.init()
 325         '''
 326         # password
 327         if len(args) > 1:
 328             adminpw = args[1]
 329         else:
 330             adminpw = ''
 331             confirm = 'x'
 332             while adminpw != confirm:
 333                 adminpw = getpass.getpass(_('Admin Password: '))
 334                 confirm = getpass.getpass(_('       Confirm: '))
 335
 336         # make sure the instance home is installed
 337         if not os.path.exists(instance_home):
 338             raise UsageError, _('Instance home does not exist')%locals()
 339         if not os.path.exists(os.path.join(instance_home, 'html')):
 340             raise UsageError, _('Instance has not been installed')%locals()
 341
 342         # is there already a database?
 343         if os.path.exists(os.path.join(instance_home, 'db')):
 344             print _('WARNING: The database is already initialised!')
 345             print _('If you re-initialise it, you will lose all the data!')
 346             ok = raw_input(_('Erase it? Y/[N]: ')).strip()
 347             if ok.lower() != 'y':
 348                 return 0
 349
 350             # nuke it
 351             shutil.rmtree(os.path.join(instance_home, 'db'))
 352
 353         # GO
 354         init.initialise(instance_home, adminpw)
 355
 356         return 0
 357
 358
 359     def do_get(self, args):
 360         '''Usage: get property designator[,designator]*
 361         Get the given property of one or more designator(s).
 362
 363         Retrieves the property value of the nodes specified by the designators.
 364         '''
 365         if len(args) < 2:
 366             raise UsageError, _('Not enough arguments supplied')
 367         propname = args[0]
 368         designators = args[1].split(',')
 369         l = []
 370         for designator in designators:
 371             # decode the node designator
 372             try:
 373                 classname, nodeid = hyperdb.splitDesignator(designator)
 374             except hyperdb.DesignatorError, message:
 375                 raise UsageError, message
 376
 377             # get the class
 378             cl = self.get_class(classname)
 379             try:
 380                 if self.comma_sep:
 381                     l.append(cl.get(nodeid, propname))
 382                 else:
 383                     print cl.get(nodeid, propname)
 384             except IndexError:
 385                 raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 386             except KeyError:
 387                 raise UsageError, _('no such %(classname)s property '
 388                     '"%(propname)s"')%locals()
 389         if self.comma_sep:
 390             print ','.join(l)
 391         return 0
 392
 393
 394     def do_set(self, args):
 395         '''Usage: set designator[,designator]* propname=value ...
 396         Set the given property of one or more designator(s).
 397
 398         Sets the property to the value for all designators given.
 399         '''
 400         if len(args) < 2:
 401             raise UsageError, _('Not enough arguments supplied')
 402         from roundup import hyperdb
 403
 404         designators = args[0].split(',')
 405
 406         # get the props from the args
 407         props = self.props_from_args(args[1:])
 408
 409         # now do the set for all the nodes
 410         for designator in designators:
 411             # decode the node designator
 412             try:
 413                 classname, nodeid = hyperdb.splitDesignator(designator)
 414             except hyperdb.DesignatorError, message:
 415                 raise UsageError, message
 416
 417             # get the class
 418             cl = self.get_class(classname)
 419
 420             properties = cl.getprops()
 421             for key, value in props.items():
 422                 proptype =  properties[key]
 423                 if isinstance(proptype, hyperdb.String):
 424                     continue
 425                 elif isinstance(proptype, hyperdb.Password):
 426                     props[key] = password.Password(value)
 427                 elif isinstance(proptype, hyperdb.Date):
 428                     try:
 429                         props[key] = date.Date(value)
 430                     except ValueError, message:
 431                         raise UsageError, '"%s": %s'%(value, message)
 432                 elif isinstance(proptype, hyperdb.Interval):
 433                     try:
 434                         props[key] = date.Interval(value)
 435                     except ValueError, message:
 436                         raise UsageError, '"%s": %s'%(value, message)
 437                 elif isinstance(proptype, hyperdb.Link):
 438                     props[key] = value
 439                 elif isinstance(proptype, hyperdb.Multilink):
 440                     props[key] = value.split(',')
 441                 elif isinstance(proptype, hyperdb.Boolean):
 442                     props[key] = value.lower() in ('yes', 'true', 'on', '1')
 443                 elif isinstance(proptype, hyperdb.Number):
 444                     props[key] = int(value)
 445
 446             # try the set
 447             try:
 448                 apply(cl.set, (nodeid, ), props)
 449             except (TypeError, IndexError, ValueError), message:
 450                 raise UsageError, message
 451         return 0
 452
 453     def do_find(self, args):
 454         '''Usage: find classname propname=value ...
 455         Find the nodes of the given class with a given link property value.
 456
 457         Find the nodes of the given class with a given link property value. The
 458         value may be either the nodeid of the linked node, or its key value.
 459         '''
 460         if len(args) < 1:
 461             raise UsageError, _('Not enough arguments supplied')
 462         classname = args[0]
 463         # get the class
 464         cl = self.get_class(classname)
 465
 466         # handle the propname=value argument
 467         props = self.props_from_args(args[1:])
 468
 469         # if the value isn't a number, look up the linked class to get the
 470         # number
 471         for propname, value in props.items():
 472             num_re = re.compile('^\d+$')
 473             if not num_re.match(value):
 474                 # get the property
 475                 try:
 476                     property = cl.properties[propname]
 477                 except KeyError:
 478                     raise UsageError, _('%(classname)s has no property '
 479                         '"%(propname)s"')%locals()
 480
 481                 # make sure it's a link
 482                 if (not isinstance(property, hyperdb.Link) and not
 483                         isinstance(property, hyperdb.Multilink)):
 484                     raise UsageError, _('You may only "find" link properties')
 485
 486                 # get the linked-to class and look up the key property
 487                 link_class = self.db.getclass(property.classname)
 488                 try:
 489                     props[propname] = link_class.lookup(value)
 490                 except TypeError:
 491                     raise UsageError, _('%(classname)s has no key property"')%{
 492                         'classname': link_class.classname}
 493
 494         # now do the find
 495         try:
 496             if self.comma_sep:
 497                 print ','.join(apply(cl.find, (), props))
 498             else:
 499                 print apply(cl.find, (), props)
 500         except KeyError:
 501             raise UsageError, _('%(classname)s has no property '
 502                 '"%(propname)s"')%locals()
 503         except (ValueError, TypeError), message:
 504             raise UsageError, message
 505         return 0
 506
 507     def do_specification(self, args):
 508         '''Usage: specification classname
 509         Show the properties for a classname.
 510
 511         This lists the properties for a given class.
 512         '''
 513         if len(args) < 1:
 514             raise UsageError, _('Not enough arguments supplied')
 515         classname = args[0]
 516         # get the class
 517         cl = self.get_class(classname)
 518
 519         # get the key property
 520         keyprop = cl.getkey()
 521         for key, value in cl.properties.items():
 522             if keyprop == key:
 523                 print _('%(key)s: %(value)s (key property)')%locals()
 524             else:
 525                 print _('%(key)s: %(value)s')%locals()
 526
 527     def do_display(self, args):
 528         '''Usage: display designator
 529         Show the property values for the given node.
 530
 531         This lists the properties and their associated values for the given
 532         node.
 533         '''
 534         if len(args) < 1:
 535             raise UsageError, _('Not enough arguments supplied')
 536
 537         # decode the node designator
 538         try:
 539             classname, nodeid = hyperdb.splitDesignator(args[0])
 540         except hyperdb.DesignatorError, message:
 541             raise UsageError, message
 542
 543         # get the class
 544         cl = self.get_class(classname)
 545
 546         # display the values
 547         for key in cl.properties.keys():
 548             value = cl.get(nodeid, key)
 549             print _('%(key)s: %(value)s')%locals()
 550
 551     def do_create(self, args):
 552         '''Usage: create classname property=value ...
 553         Create a new entry of a given class.
 554
 555         This creates a new entry of the given class using the property
 556         name=value arguments provided on the command line after the "create"
 557         command.
 558         '''
 559         if len(args) < 1:
 560             raise UsageError, _('Not enough arguments supplied')
 561         from roundup import hyperdb
 562
 563         classname = args[0]
 564
 565         # get the class
 566         cl = self.get_class(classname)
 567
 568         # now do a create
 569         props = {}
 570         properties = cl.getprops(protected = 0)
 571         if len(args) == 1:
 572             # ask for the properties
 573             for key, value in properties.items():
 574                 if key == 'id': continue
 575                 name = value.__class__.__name__
 576                 if isinstance(value , hyperdb.Password):
 577                     again = None
 578                     while value != again:
 579                         value = getpass.getpass(_('%(propname)s (Password): ')%{
 580                             'propname': key.capitalize()})
 581                         again = getpass.getpass(_('   %(propname)s (Again): ')%{
 582                             'propname': key.capitalize()})
 583                         if value != again: print _('Sorry, try again...')
 584                     if value:
 585                         props[key] = value
 586                 else:
 587                     value = raw_input(_('%(propname)s (%(proptype)s): ')%{
 588                         'propname': key.capitalize(), 'proptype': name})
 589                     if value:
 590                         props[key] = value
 591         else:
 592             props = self.props_from_args(args[1:])
 593
 594         # convert types
 595         for propname, value in props.items():
 596             # get the property
 597             try:
 598                 proptype = properties[propname]
 599             except KeyError:
 600                 raise UsageError, _('%(classname)s has no property '
 601                     '"%(propname)s"')%locals()
 602
 603             if isinstance(proptype, hyperdb.Date):
 604                 try:
 605                     props[propname] = date.Date(value)
 606                 except ValueError, message:
 607                     raise UsageError, _('"%(value)s": %(message)s')%locals()
 608             elif isinstance(proptype, hyperdb.Interval):
 609                 try:
 610                     props[propname] = date.Interval(value)
 611                 except ValueError, message:
 612                     raise UsageError, _('"%(value)s": %(message)s')%locals()
 613             elif isinstance(proptype, hyperdb.Password):
 614                 props[propname] = password.Password(value)
 615             elif isinstance(proptype, hyperdb.Multilink):
 616                 props[propname] = value.split(',')
 617             elif isinstance(proptype, hyperdb.Boolean):
 618                 props[propname] = value.lower() in ('yes', 'true', 'on', '1')
 619             elif isinstance(proptype, hyperdb.Number):
 620                 props[propname] = int(value)
 621
 622         # check for the key property
 623         propname = cl.getkey()
 624         if propname and not props.has_key(propname):
 625             raise UsageError, _('you must provide the "%(propname)s" '
 626                 'property.')%locals()
 627
 628         # do the actual create
 629         try:
 630             print apply(cl.create, (), props)
 631         except (TypeError, IndexError, ValueError), message:
 632             raise UsageError, message
 633         return 0
 634
 635     def do_list(self, args):
 636         '''Usage: list classname [property]
 637         List the instances of a class.
 638
 639         Lists all instances of the given class. If the property is not
 640         specified, the  "label" property is used. The label property is tried
 641         in order: the key, "name", "title" and then the first property,
 642         alphabetically.
 643         '''
 644         if len(args) < 1:
 645             raise UsageError, _('Not enough arguments supplied')
 646         classname = args[0]
 647
 648         # get the class
 649         cl = self.get_class(classname)
 650
 651         # figure the property
 652         if len(args) > 1:
 653             propname = args[1]
 654         else:
 655             propname = cl.labelprop()
 656
 657         if self.comma_sep:
 658             print ','.join(cl.list())
 659         else:
 660             for nodeid in cl.list():
 661                 try:
 662                     value = cl.get(nodeid, propname)
 663                 except KeyError:
 664                     raise UsageError, _('%(classname)s has no property '
 665                         '"%(propname)s"')%locals()
 666                 print _('%(nodeid)4s: %(value)s')%locals()
 667         return 0
 668
 669     def do_table(self, args):
 670         '''Usage: table classname [property[,property]*]
 671         List the instances of a class in tabular form.
 672
 673         Lists all instances of the given class. If the properties are not
 674         specified, all properties are displayed. By default, the column widths
 675         are the width of the property names. The width may be explicitly defined
 676         by defining the property as "name:width". For example::
 677           roundup> table priority id,name:10
 678           Id Name
 679           1  fatal-bug
 680           2  bug
 681           3  usability
 682           4  feature
 683         '''
 684         if len(args) < 1:
 685             raise UsageError, _('Not enough arguments supplied')
 686         classname = args[0]
 687
 688         # get the class
 689         cl = self.get_class(classname)
 690
 691         # figure the property names to display
 692         if len(args) > 1:
 693             prop_names = args[1].split(',')
 694             all_props = cl.getprops()
 695             for spec in prop_names:
 696                 if ':' in spec:
 697                     try:
 698                         propname, width = spec.split(':')
 699                     except (ValueError, TypeError):
 700                         raise UsageError, _('"%(spec)s" not name:width')%locals()
 701                 else:
 702                     propname = spec
 703                 if not all_props.has_key(propname):
 704                     raise UsageError, _('%(classname)s has no property '
 705                         '"%(propname)s"')%locals()
 706         else:
 707             prop_names = cl.getprops().keys()
 708
 709         # now figure column widths
 710         props = []
 711         for spec in prop_names:
 712             if ':' in spec:
 713                 name, width = spec.split(':')
 714                 props.append((name, int(width)))
 715             else:
 716                 props.append((spec, len(spec)))
 717
 718         # now display the heading
 719         print ' '.join([name.capitalize().ljust(width) for name,width in props])
 720
 721         # and the table data
 722         for nodeid in cl.list():
 723             l = []
 724             for name, width in props:
 725                 if name != 'id':
 726                     try:
 727                         value = str(cl.get(nodeid, name))
 728                     except KeyError:
 729                         # we already checked if the property is valid - a
 730                         # KeyError here means the node just doesn't have a
 731                         # value for it
 732                         value = ''
 733                 else:
 734                     value = str(nodeid)
 735                 f = '%%-%ds'%width
 736                 l.append(f%value[:width])
 737             print ' '.join(l)
 738         return 0
 739
 740     def do_history(self, args):
 741         '''Usage: history designator
 742         Show the history entries of a designator.
 743
 744         Lists the journal entries for the node identified by the designator.
 745         '''
 746         if len(args) < 1:
 747             raise UsageError, _('Not enough arguments supplied')
 748         try:
 749             classname, nodeid = hyperdb.splitDesignator(args[0])
 750         except hyperdb.DesignatorError, message:
 751             raise UsageError, message
 752
 753         try:
 754             print self.db.getclass(classname).history(nodeid)
 755         except KeyError:
 756             raise UsageError, _('no such class "%(classname)s"')%locals()
 757         except IndexError:
 758             raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 759         return 0
 760
 761     def do_commit(self, args):
 762         '''Usage: commit
 763         Commit all changes made to the database.
 764
 765         The changes made during an interactive session are not
 766         automatically written to the database - they must be committed
 767         using this command.
 768
 769         One-off commands on the command-line are automatically committed if
 770         they are successful.
 771         '''
 772         self.db.commit()
 773         return 0
 774
 775     def do_rollback(self, args):
 776         '''Usage: rollback
 777         Undo all changes that are pending commit to the database.
 778
 779         The changes made during an interactive session are not
 780         automatically written to the database - they must be committed
 781         manually. This command undoes all those changes, so a commit
 782         immediately after would make no changes to the database.
 783         '''
 784         self.db.rollback()
 785         return 0
 786
 787     def do_retire(self, args):
 788         '''Usage: retire designator[,designator]*
 789         Retire the node specified by designator.
 790
 791         This action indicates that a particular node is not to be retrieved by
 792         the list or find commands, and its key value may be re-used.
 793         '''
 794         if len(args) < 1:
 795             raise UsageError, _('Not enough arguments supplied')
 796         designators = args[0].split(',')
 797         for designator in designators:
 798             try:
 799                 classname, nodeid = hyperdb.splitDesignator(designator)
 800             except hyperdb.DesignatorError, message:
 801                 raise UsageError, message
 802             try:
 803                 self.db.getclass(classname).retire(nodeid)
 804             except KeyError:
 805                 raise UsageError, _('no such class "%(classname)s"')%locals()
 806             except IndexError:
 807                 raise UsageError, _('no such %(classname)s node "%(nodeid)s"')%locals()
 808         return 0
 809
 810     def do_export(self, args):
 811         '''Usage: export class[,class] destination_dir
 812         Export the database to tab-separated-value files.
 813
 814         This action exports the current data from the database into
 815         tab-separated-value files that are placed in the nominated destination
 816         directory. The journals are not exported.
 817         '''
 818         if len(args) < 2:
 819             raise UsageError, _('Not enough arguments supplied')
 820         classes = args[0].split(',')
 821         dir = args[1]
 822
 823         # use the csv parser if we can - it's faster
 824         if csv is not None:
 825             p = csv.parser(field_sep=':')
 826
 827         # do all the classes specified
 828         for classname in classes:
 829             cl = self.get_class(classname)
 830             f = open(os.path.join(dir, classname+'.csv'), 'w')
 831             f.write(':'.join(cl.properties.keys()) + '\n')
 832
 833             # all nodes for this class
 834             properties = cl.properties.items()
 835             for nodeid in cl.list():
 836                 l = []
 837                 for prop, proptype in properties:
 838                     value = cl.get(nodeid, prop)
 839                     # convert data where needed
 840                     if isinstance(proptype, hyperdb.Date):
 841                         value = value.get_tuple()
 842                     elif isinstance(proptype, hyperdb.Interval):
 843                         value = value.get_tuple()
 844                     elif isinstance(proptype, hyperdb.Password):
 845                         value = str(value)
 846                     l.append(repr(value))
 847
 848                 # now write
 849                 if csv is not None:
 850                    f.write(p.join(l) + '\n')
 851                 else:
 852                    # escape the individual entries to they're valid CSV
 853                    m = []
 854                    for entry in l:
 855                       if '"' in entry:
 856                           entry = '""'.join(entry.split('"'))
 857                       if ':' in entry:
 858                           entry = '"%s"'%entry
 859                       m.append(entry)
 860                    f.write(':'.join(m) + '\n')
 861         return 0
 862
 863     def do_import(self, args):
 864         '''Usage: import class file
 865         Import the contents of the tab-separated-value file.
 866
 867         The file must define the same properties as the class (including having
 868         a "header" line with those property names.) The new nodes are added to
 869         the existing database - if you want to create a new database using the
 870         imported data, then create a new database (or, tediously, retire all
 871         the old data.)
 872         '''
 873         if len(args) < 2:
 874             raise UsageError, _('Not enough arguments supplied')
 875         if csv is None:
 876             raise UsageError, \
 877                 _('Sorry, you need the csv module to use this function.\n'
 878                 'Get it from: http://www.object-craft.com.au/projects/csv/')
 879
 880         from roundup import hyperdb
 881
 882         # ensure that the properties and the CSV file headings match
 883         classname = args[0]
 884         cl = self.get_class(classname)
 885         f = open(args[1])
 886         p = csv.parser(field_sep=':')
 887         file_props = p.parse(f.readline())
 888         props = cl.properties.keys()
 889         m = file_props[:]
 890         m.sort()
 891         props.sort()
 892         if m != props:
 893             raise UsageError, _('Import file doesn\'t define the same '
 894                 'properties as "%(arg0)s".')%{'arg0': args[0]}
 895
 896         # loop through the file and create a node for each entry
 897         n = range(len(props))
 898         while 1:
 899             line = f.readline()
 900             if not line: break
 901
 902             # parse lines until we get a complete entry
 903             while 1:
 904                 l = p.parse(line)
 905                 if l: break
 906                 line = f.readline()
 907                 if not line:
 908                     raise ValueError, "Unexpected EOF during CSV parse"
 909
 910             # make the new node's property map
 911             d = {}
 912             for i in n:
 913                 # Use eval to reverse the repr() used to output the CSV
 914                 value = eval(l[i])
 915                 # Figure the property for this column
 916                 key = file_props[i]
 917                 proptype = cl.properties[key]
 918                 # Convert for property type
 919                 if isinstance(proptype, hyperdb.Date):
 920                     value = date.Date(value)
 921                 elif isinstance(proptype, hyperdb.Interval):
 922                     value = date.Interval(value)
 923                 elif isinstance(proptype, hyperdb.Password):
 924                     pwd = password.Password()
 925                     pwd.unpack(value)
 926                     value = pwd
 927                 if value is not None:
 928                     d[key] = value
 929
 930             # and create the new node
 931             apply(cl.create, (), d)
 932         return 0
 933
 934     def do_pack(self, args):
 935         '''Usage: pack period | date
 936
 937 Remove journal entries older than a period of time specified or
 938 before a certain date.
 939
 940 A period is specified using the suffixes "y", "m", and "d". The
 941 suffix "w" (for "week") means 7 days.
 942
 943       "3y" means three years
 944       "2y 1m" means two years and one month
 945       "1m 25d" means one month and 25 days
 946       "2w 3d" means two weeks and three days
 947
 948 Date format is "YYYY-MM-DD" eg:
 949     2001-01-01
 950
 951         '''
 952         if len(args) <> 1:
 953             raise UsageError, _('Not enough arguments supplied')
 954
 955         # are we dealing with a period or a date
 956         value = args[0]
 957         date_re = re.compile(r'''
 958               (?P<date>\d\d\d\d-\d\d?-\d\d?)? # yyyy-mm-dd
 959               (?P<period>(\d+y\s*)?(\d+m\s*)?(\d+d\s*)?)?
 960               ''', re.VERBOSE)
 961         m = date_re.match(value)
 962         if not m:
 963             raise ValueError, _('Invalid format')
 964         m = m.groupdict()
 965         if m['period']:
 966             pack_before = date.Date(". - %s"%value)
 967         elif m['date']:
 968             pack_before = date.Date(value)
 969         self.db.pack(pack_before)
 970         return 0
 971
 972     def do_reindex(self, args):
 973         '''Usage: reindex
 974         Re-generate an instance's search indexes.
 975
 976         This will re-generate the search indexes for an instance. This will
 977         typically happen automatically.
 978         '''
 979         self.db.indexer.force_reindex()
 980         self.db.reindex()
 981         return 0
 982
 983     def do_security(self, args):
 984         '''Usage: security [Role name]
 985         Display the Permissions available to one or all Roles.
 986         '''
 987         if len(args) == 1:
 988             role = args[0]
 989             try:
 990                 roles = [(args[0], self.db.security.role[args[0]])]
 991             except KeyError:
 992                 print _('No such Role "%(role)s"')%locals()
 993                 return 1
 994         else:
 995             roles = self.db.security.role.items()
 996         roles.sort()
 997         for rolename, role in roles:
 998             print _('Role "%(name)s":')%role.__dict__
 999             for permission in role.permissions:
1000                 if permission.klass:
1001                     print _(' %(description)s (%(name)s for "%(klass)s" '
1002                         'only)')%permission.__dict__
1003                 else:
1004                     print _(' %(description)s (%(name)s)')%permission.__dict__
1005         return 0
1006
1007     def run_command(self, args):
1008         '''Run a single command
1009         '''
1010         command = args[0]
1011
1012         # handle help now
1013         if command == 'help':
1014             if len(args)>1:
1015                 self.do_help(args[1:])
1016                 return 0
1017             self.do_help(['help'])
1018             return 0
1019         if command == 'morehelp':
1020             self.do_help(['help'])
1021             self.help_commands()
1022             self.help_all()
1023             return 0
1024
1025         # figure what the command is
1026         try:
1027             functions = self.commands.get(command)
1028         except KeyError:
1029             # not a valid command
1030             print _('Unknown command "%(command)s" ("help commands" for a '
1031                 'list)')%locals()
1032             return 1
1033
1034         # check for multiple matches
1035         if len(functions) > 1:
1036             print _('Multiple commands match "%(command)s": %(list)s')%{'command':
1037                 command, 'list': ', '.join([i[0] for i in functions])}
1038             return 1
1039         command, function = functions[0]
1040
1041         # make sure we have an instance_home
1042         while not self.instance_home:
1043             self.instance_home = raw_input(_('Enter instance home: ')).strip()
1044
1045         # before we open the db, we may be doing an install or init
1046         if command == 'initialise':
1047             try:
1048                 return self.do_initialise(self.instance_home, args)
1049             except UsageError, message:
1050                 print _('Error: %(message)s')%locals()
1051                 return 1
1052         elif command == 'install':
1053             try:
1054                 return self.do_install(self.instance_home, args)
1055             except UsageError, message:
1056                 print _('Error: %(message)s')%locals()
1057                 return 1
1058
1059         # get the instance
1060         try:
1061             instance = roundup.instance.open(self.instance_home)
1062         except ValueError, message:
1063             self.instance_home = ''
1064             print _("Error: Couldn't open instance: %(message)s")%locals()
1065             return 1
1066
1067         # only open the database once!
1068         if not self.db:
1069             self.db = instance.open('admin')
1070
1071         # do the command
1072         ret = 0
1073         try:
1074             ret = function(args[1:])
1075         except UsageError, message:
1076             print _('Error: %(message)s')%locals()
1077             print
1078             print function.__doc__
1079             ret = 1
1080         except:
1081             import traceback
1082             traceback.print_exc()
1083             ret = 1
1084         return ret
1085
1086     def interactive(self):
1087         '''Run in an interactive mode
1088         '''
1089         print _('Roundup %s ready for input.'%roundup_version)
1090         print _('Type "help" for help.')
1091         try:
1092             import readline
1093         except ImportError:
1094             print _('Note: command history and editing not available')
1095
1096         while 1:
1097             try:
1098                 command = raw_input(_('roundup> '))
1099             except EOFError:
1100                 print _('exit...')
1101                 break
1102             if not command: continue
1103             args = token.token_split(command)
1104             if not args: continue
1105             if args[0] in ('quit', 'exit'): break
1106             self.run_command(args)
1107
1108         # exit.. check for transactions
1109         if self.db and self.db.transactions:
1110             commit = raw_input(_('There are unsaved changes. Commit them (y/N)? '))
1111             if commit and commit[0].lower() == 'y':
1112                 self.db.commit()
1113         return 0
1114
1115     def main(self):
1116         try:
1117             opts, args = getopt.getopt(sys.argv[1:], 'i:u:hc')
1118         except getopt.GetoptError, e:
1119             self.usage(str(e))
1120             return 1
1121
1122         # handle command-line args
1123         self.instance_home = os.environ.get('ROUNDUP_INSTANCE', '')
1124         # TODO: reinstate the user/password stuff (-u arg too)
1125         name = password = ''
1126         if os.environ.has_key('ROUNDUP_LOGIN'):
1127             l = os.environ['ROUNDUP_LOGIN'].split(':')
1128             name = l[0]
1129             if len(l) > 1:
1130                 password = l[1]
1131         self.comma_sep = 0
1132         for opt, arg in opts:
1133             if opt == '-h':
1134                 self.usage()
1135                 return 0
1136             if opt == '-i':
1137                 self.instance_home = arg
1138             if opt == '-c':
1139                 self.comma_sep = 1
1140
1141         # if no command - go interactive
1142         ret = 0
1143         if not args:
1144             self.interactive()
1145         else:
1146             ret = self.run_command(args)
1147             if self.db: self.db.commit()
1148         return ret
1149
1150
1151 if __name__ == '__main__':
1152     tool = AdminTool()
1153     sys.exit(tool.main())
1154
1155 #
1156 # $Log: not supported by cvs2svn $
1157 # Revision 1.19  2002/07/25 07:14:05  richard
1158 # Bugger it. Here's the current shape of the new security implementation.
1159 # Still to do:
1160 #  . call the security funcs from cgi and mailgw
1161 #  . change shipped templates to include correct initialisation and remove
1162 #    the old config vars
1163 # ... that seems like a lot. The bulk of the work has been done though. Honest :)
1164 #
1165 # Revision 1.18  2002/07/18 11:17:30  gmcm
1166 # Add Number and Boolean types to hyperdb.
1167 # Add conversion cases to web, mail & admin interfaces.
1168 # Add storage/serialization cases to back_anydbm & back_metakit.
1169 #
1170 # Revision 1.17  2002/07/14 06:05:50  richard
1171 #  . fixed the date module so that Date(". - 2d") works
1172 #
1173 # Revision 1.16  2002/07/09 04:19:09  richard
1174 # Added reindex command to roundup-admin.
1175 # Fixed reindex on first access.
1176 # Also fixed reindexing of entries that change.
1177 #
1178 # Revision 1.15  2002/06/17 23:14:44  richard
1179 # . #569415 ] {version}
1180 #
1181 # Revision 1.14  2002/06/11 06:41:50  richard
1182 # Removed prompt for admin email in initialisation.
1183 #
1184 # Revision 1.13  2002/05/30 23:58:14  richard
1185 # oops
1186 #
1187 # Revision 1.12  2002/05/26 09:04:42  richard
1188 # out by one in the init args
1189 #
1190 # Revision 1.11  2002/05/23 01:14:20  richard
1191 #  . split instance initialisation into two steps, allowing config changes
1192 #    before the database is initialised.
1193 #
1194 # Revision 1.10  2002/04/27 10:07:23  richard
1195 # minor fix to error message
1196 #
1197 # Revision 1.9  2002/03/12 22:51:47  richard
1198 #  . #527416 ] roundup-admin uses undefined value
1199 #  . #527503 ] unfriendly init blowup when parent dir
1200 #    (also handles UsageError correctly now in init)
1201 #
1202 # Revision 1.8  2002/02/27 03:28:21  richard
1203 # Ran it through pychecker, made fixes
1204 #
1205 # Revision 1.7  2002/02/20 05:04:32  richard
1206 # Wasn't handling the cvs parser feeding properly.
1207 #
1208 # Revision 1.6  2002/01/23 07:27:19  grubert
1209 #  . allow abbreviation of "help" in admin tool too.
1210 #
1211 # Revision 1.5  2002/01/21 16:33:19  rochecompaan
1212 # You can now use the roundup-admin tool to pack the database
1213 #
1214 # Revision 1.4  2002/01/14 06:51:09  richard
1215 #  . #503164 ] create and passwords
1216 #
1217 # Revision 1.3  2002/01/08 05:26:32  rochecompaan
1218 # Missing "self" in props_from_args
1219 #
1220 # Revision 1.2  2002/01/07 10:41:44  richard
1221 # #500140 ] AdminTool.get_class() returns nothing
1222 #
1223 # Revision 1.1  2002/01/05 02:11:22  richard
1224 # I18N'ed roundup admin - and split the code off into a module so it can be used
1225 # elsewhere.
1226 # Big issue with this is the doc strings - that's the help. We're probably going to
1227 # have to switch to not use docstrings, which will suck a little :(
1228 #
1229 #
1230 #
1231 # vim: set filetype=python ts=4 sw=4 et si