OwlCyberSecurity - MANAGER

Edit File: dbinspect.py

#!/usr/bin/env python
# -*- test-case-name: calendarserver.tools.test.test_calverify -*-
##
# Copyright (c) 2011-2017 Apple Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from __future__ import print_function

"""
This tool allows data in the database to be directly inspected using a set
of simple commands.
"""

from calendarserver.tools import tables
from calendarserver.tools.cmdline import utilityMain, WorkerService
from pycalendar.datetime import DateTime

from twext.enterprise.dal.syntax import Select, Parameter, Count, Delete, \
    ALL_COLUMNS
from twext.who.idirectory import RecordType

from twisted.internet.defer import inlineCallbacks, returnValue, succeed
from twisted.python.filepath import FilePath
from twisted.python.text import wordWrap
from twisted.python.usage import Options

from twistedcaldav import caldavxml
from twistedcaldav.config import config
from twistedcaldav.directory import calendaruserproxy
from twistedcaldav.stdconfig import DEFAULT_CONFIG_FILE

from txdav.caldav.datastore.query.filter import Filter
from txdav.common.datastore.sql_tables import schema, _BIND_MODE_OWN
from txdav.who.idirectory import RecordType as CalRecordType

from uuid import UUID
import os
import sys
import traceback

def usage(e=None):
    if e:
        print(e)
        print("")
    try:
        DBInspectOptions().opt_help()
    except SystemExit:
        pass
    if e:
        sys.exit(64)
    else:
        sys.exit(0)

description = '\n'.join(
    wordWrap(
        """
        Usage: calendarserver_dbinspect [options] [input specifiers]\n
        """,
        int(os.environ.get('COLUMNS', '80'))
    )
)

class DBInspectOptions(Options):
    """
    Command-line options for 'calendarserver_dbinspect'
    """

synopsis = description

optFlags = [
        ['verbose', 'v', "Verbose logging."],
        ['debug', 'D', "Debug logging."],
        ['purging', 'p', "Enable Purge command."],
    ]

optParameters = [
        ['config', 'f', DEFAULT_CONFIG_FILE, "Specify caldavd.plist configuration path."],
    ]

def __init__(self):
        super(DBInspectOptions, self).__init__()
        self.outputName = '-'

@inlineCallbacks
def UserNameFromUID(txn, uid):
    record = yield txn.directoryService().recordWithUID(uid)
    returnValue(record.shortNames[0] if record else "(%s)" % (uid,))

@inlineCallbacks
def UIDFromInput(txn, value):
    try:
        returnValue(str(UUID(value)).upper())
    except (ValueError, TypeError):
        pass

record = yield txn.directoryService().recordWithShortName(RecordType.user, value)
    if record is None:
        record = yield txn.directoryService().recordWithShortName(CalRecordType.location, value)
    if record is None:
        record = yield txn.directoryService().recordWithShortName(CalRecordType.resource, value)
    if record is None:
        record = yield txn.directoryService().recordWithShortName(RecordType.group, value)
    returnValue(record.uid if record else None)

class Cmd(object):

_name = None

@classmethod
    def name(cls):
        return cls._name

def doIt(self, txn):
        raise NotImplementedError

class TableSizes(Cmd):

_name = "Show Size of each Table"

@inlineCallbacks
    def doIt(self, txn):

results = []
        for dbtable in schema.model.tables:  # @UndefinedVariable
            dbtable = getattr(schema, dbtable.name)
            count = yield self.getTableSize(txn, dbtable)
            results.append((dbtable.model.name, count,))

# Print table of results
        table = tables.Table()
        table.addHeader(("Table", "Row Count"))
        for dbtable, count in sorted(results):
            table.addRow((
                dbtable,
                count,
            ))

print("\n")
        print("Database Tables (total=%d):\n" % (len(results),))
        table.printTable()

@inlineCallbacks
    def getTableSize(self, txn, dbtable):
        rows = (yield Select(
            [Count(ALL_COLUMNS), ],
            From=dbtable,
        ).on(txn))
        returnValue(rows[0][0])

class CalendarHomes(Cmd):

_name = "List Calendar Homes"

@inlineCallbacks
    def doIt(self, txn):

uids = yield self.getAllHomeUIDs(txn)

# Print table of results
        missing = 0
        table = tables.Table()
        table.addHeader(("Owner UID", "Short Name"))
        for uid in sorted(uids):
            shortname = yield UserNameFromUID(txn, uid)
            if shortname.startswith("("):
                missing += 1
            table.addRow((
                uid,
                shortname,
            ))

print("\n")
        print("Calendar Homes (total=%d, missing=%d):\n" % (len(uids), missing,))
        table.printTable()

@inlineCallbacks
    def getAllHomeUIDs(self, txn):
        ch = schema.CALENDAR_HOME
        rows = (yield Select(
            [ch.OWNER_UID, ],
            From=ch,
        ).on(txn))
        returnValue(tuple([row[0] for row in rows]))

class CalendarHomesSummary(Cmd):

_name = "List Calendar Homes with summary information"

@inlineCallbacks
    def doIt(self, txn):

uids = yield self.getCalendars(txn)

results = {}
        for uid, calname, count in sorted(uids, key=lambda x: x[0]):
            totalname, totalcount = results.get(uid, (0, 0,))
            if calname != "inbox":
                totalname += 1
                totalcount += count
                results[uid] = (totalname, totalcount,)

# Print table of results
        table = tables.Table()
        table.addHeader(("Owner UID", "Short Name", "Calendars", "Resources"))
        totals = [0, 0, 0]
        for uid in sorted(results.keys()):
            shortname = yield UserNameFromUID(txn, uid)
            table.addRow((
                uid,
                shortname,
                results[uid][0],
                results[uid][1],
            ))
            totals[0] += 1
            totals[1] += results[uid][0]
            totals[2] += results[uid][1]
        table.addFooter(("Total", totals[0], totals[1], totals[2]))
        table.addFooter((
            "Average",
            "",
            "%.2f" % ((1.0 * totals[1]) / totals[0] if totals[0] else 0,),
            "%.2f" % ((1.0 * totals[2]) / totals[0] if totals[0] else 0,),
        ))

print("\n")
        print("Calendars with resource count (total=%d):\n" % (len(results),))
        table.printTable()

@inlineCallbacks
    def getCalendars(self, txn):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        rows = (yield Select(
            [
                ch.OWNER_UID,
                cb.CALENDAR_RESOURCE_NAME,
                Count(co.RESOURCE_ID),
            ],
            From=ch.join(
                cb, type="inner", on=(ch.RESOURCE_ID == cb.CALENDAR_HOME_RESOURCE_ID).And(
                    cb.BIND_MODE == _BIND_MODE_OWN)).join(
                co, type="left", on=(cb.CALENDAR_RESOURCE_ID == co.CALENDAR_RESOURCE_ID)),
            GroupBy=(ch.OWNER_UID, cb.CALENDAR_RESOURCE_NAME)
        ).on(txn))
        returnValue(tuple(rows))

class Calendars(Cmd):

_name = "List Calendars"

@inlineCallbacks
    def doIt(self, txn):

uids = yield self.getCalendars(txn)

# Print table of results
        table = tables.Table()
        table.addHeader(("Owner UID", "Short Name", "Calendar", "Resources"))
        for uid, calname, count in sorted(uids, key=lambda x: (x[0], x[1])):
            shortname = yield UserNameFromUID(txn, uid)
            table.addRow((
                uid,
                shortname,
                calname,
                count
            ))

print("\n")
        print("Calendars with resource count (total=%d):\n" % (len(uids),))
        table.printTable()

class CalendarsByOwner(Cmd):

_name = "List Calendars for Owner UID/Short Name"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("Owner UID/Name: ")
        uid = yield UIDFromInput(txn, uid)
        uids = yield self.getCalendars(txn, uid)

# Print table of results
        table = tables.Table()
        table.addHeader(("Owner UID", "Short Name", "Calendars", "ID", "Resources"))
        totals = [0, 0, ]
        for uid, calname, resid, count in sorted(uids, key=lambda x: x[1]):
            shortname = yield UserNameFromUID(txn, uid)
            table.addRow((
                uid if totals[0] == 0 else "",
                shortname if totals[0] == 0 else "",
                calname,
                resid,
                count,
            ))
            totals[0] += 1
            totals[1] += count
        table.addFooter(("Total", "", totals[0], "", totals[1]))

print("\n")
        print("Calendars with resource count (total=%d):\n" % (len(uids),))
        table.printTable()

@inlineCallbacks
    def getCalendars(self, txn, uid):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        rows = (yield Select(
            [
                ch.OWNER_UID,
                cb.CALENDAR_RESOURCE_NAME,
                co.CALENDAR_RESOURCE_ID,
                Count(co.RESOURCE_ID),
            ],
            From=ch.join(
                cb, type="inner", on=(ch.RESOURCE_ID == cb.CALENDAR_HOME_RESOURCE_ID).And(
                    cb.BIND_MODE == _BIND_MODE_OWN)).join(
                co, type="left", on=(cb.CALENDAR_RESOURCE_ID == co.CALENDAR_RESOURCE_ID)),
            Where=(ch.OWNER_UID == Parameter("UID")),
            GroupBy=(ch.OWNER_UID, cb.CALENDAR_RESOURCE_NAME, co.CALENDAR_RESOURCE_ID)
        ).on(txn, **{"UID": uid}))
        returnValue(tuple(rows))

class Events(Cmd):

_name = "List Events"

@inlineCallbacks
    def doIt(self, txn):

uids = yield self.getEvents(txn)

# Print table of results
        table = tables.Table()
        table.addHeader(("Owner UID", "Short Name", "Calendar", "ID", "Type", "UID"))
        for uid, calname, id, caltype, caluid in sorted(uids, key=lambda x: (x[0], x[1])):
            shortname = yield UserNameFromUID(txn, uid)
            table.addRow((
                uid,
                shortname,
                calname,
                id,
                caltype,
                caluid
            ))

print("\n")
        print("Calendar events (total=%d):\n" % (len(uids),))
        table.printTable()

@inlineCallbacks
    def getEvents(self, txn):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        rows = (yield Select(
            [
                ch.OWNER_UID,
                cb.CALENDAR_RESOURCE_NAME,
                co.RESOURCE_ID,
                co.ICALENDAR_TYPE,
                co.ICALENDAR_UID,
            ],
            From=ch.join(
                cb, type="inner", on=(ch.RESOURCE_ID == cb.CALENDAR_HOME_RESOURCE_ID).And(
                    cb.BIND_MODE == _BIND_MODE_OWN)).join(
                co, type="inner", on=(cb.CALENDAR_RESOURCE_ID == co.CALENDAR_RESOURCE_ID)),
        ).on(txn))
        returnValue(tuple(rows))

class EventsByCalendar(Cmd):

_name = "List Events for a specific calendar"

@inlineCallbacks
    def doIt(self, txn):

rid = raw_input("Resource-ID: ")
        try:
            int(rid)
        except ValueError:
            print('Resource ID must be an integer')
            returnValue(None)
        uids = yield self.getEvents(txn, rid)

# Print table of results
        table = tables.Table()
        table.addHeader(("Type", "UID", "Resource Name", "Resource ID",))
        for caltype, caluid, rname, rid in sorted(uids, key=lambda x: x[1]):
            table.addRow((
                caltype,
                caluid,
                rname,
                rid,
            ))

print("\n")
        print("Calendar events (total=%d):\n" % (len(uids),))
        table.printTable()

@inlineCallbacks
    def getEvents(self, txn, rid):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        rows = (yield Select(
            [
                co.ICALENDAR_TYPE,
                co.ICALENDAR_UID,
                co.RESOURCE_NAME,
                co.RESOURCE_ID,
            ],
            From=ch.join(
                cb, type="inner", on=(ch.RESOURCE_ID == cb.CALENDAR_HOME_RESOURCE_ID).And(
                    cb.BIND_MODE == _BIND_MODE_OWN)).join(
                co, type="inner", on=(cb.CALENDAR_RESOURCE_ID == co.CALENDAR_RESOURCE_ID)),
            Where=(co.CALENDAR_RESOURCE_ID == Parameter("RID")),
        ).on(txn, **{"RID": rid}))
        returnValue(tuple(rows))

class EventDetails(Cmd):
    """
    Base class for common event details commands.
    """
    @inlineCallbacks
    def printEventDetails(self, txn, details):
        owner, calendar, resource_id, resource, created, modified, data = details
        shortname = yield UserNameFromUID(txn, owner)
        table = tables.Table()
        table.addRow(("Owner UID:", owner,))
        table.addRow(("User Name:", shortname,))
        table.addRow(("Calendar:", calendar,))
        table.addRow(("Resource Name:", resource))
        table.addRow(("Resource ID:", resource_id))
        table.addRow(("Created", created))
        table.addRow(("Modified", modified))
        print("\n")
        table.printTable()
        print(data)

@inlineCallbacks
    def getEventData(self, txn, whereClause, whereParams):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        rows = (yield Select(
            [
                ch.OWNER_UID,
                cb.CALENDAR_RESOURCE_NAME,
                co.RESOURCE_ID,
                co.RESOURCE_NAME,
                co.CREATED,
                co.MODIFIED,
                co.ICALENDAR_TEXT,
            ],
            From=ch.join(
                cb, type="inner", on=(ch.RESOURCE_ID == cb.CALENDAR_HOME_RESOURCE_ID).And(
                    cb.BIND_MODE == _BIND_MODE_OWN)).join(
                co, type="inner", on=(cb.CALENDAR_RESOURCE_ID == co.CALENDAR_RESOURCE_ID)),
            Where=whereClause,
        ).on(txn, **whereParams))
        returnValue(tuple(rows))

class Event(EventDetails):

_name = "Get Event Data by Resource-ID"

@inlineCallbacks
    def doIt(self, txn):

rid = raw_input("Resource-ID: ")
        try:
            int(rid)
        except ValueError:
            print('Resource ID must be an integer')
            returnValue(None)
        result = yield self.getData(txn, rid)
        if result:
            yield self.printEventDetails(txn, result[0])
        else:
            print("Could not find resource")

def getData(self, txn, rid):
        co = schema.CALENDAR_OBJECT
        return self.getEventData(txn, (co.RESOURCE_ID == Parameter("RID")), {"RID": rid})

class EventsByUID(EventDetails):

_name = "Get Event Data by iCalendar UID"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("UID: ")
        rows = yield self.getData(txn, uid)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, uid):
        co = schema.CALENDAR_OBJECT
        return self.getEventData(txn, (co.ICALENDAR_UID == Parameter("UID")), {"UID": uid})

class EventsByName(EventDetails):

_name = "Get Event Data by resource name"

@inlineCallbacks
    def doIt(self, txn):

name = raw_input("Resource Name: ")
        rows = yield self.getData(txn, name)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, name):
        co = schema.CALENDAR_OBJECT
        return self.getEventData(txn, (co.RESOURCE_NAME == Parameter("NAME")), {"NAME": name})

class EventsByOwner(EventDetails):

_name = "Get Event Data by Owner UID/Short Name"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("Owner UID/Name: ")
        uid = yield UIDFromInput(txn, uid)
        rows = yield self.getData(txn, uid)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, uid):
        ch = schema.CALENDAR_HOME
        return self.getEventData(txn, (ch.OWNER_UID == Parameter("UID")), {"UID": uid})

class EventsByOwnerCalendar(EventDetails):

_name = "Get Event Data by Owner UID/Short Name and calendar name"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("Owner UID/Name: ")
        uid = yield UIDFromInput(txn, uid)
        name = raw_input("Calendar resource name: ")
        rows = yield self.getData(txn, uid, name)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, uid, name):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        return self.getEventData(txn, (ch.OWNER_UID == Parameter("UID")).And(cb.CALENDAR_RESOURCE_NAME == Parameter("NAME")), {"UID": uid, "NAME": name})

class EventsByPath(EventDetails):

_name = "Get Event Data by HTTP Path"

@inlineCallbacks
    def doIt(self, txn):

path = raw_input("Path: ")
        pathbits = path.split("/")
        if len(pathbits) != 6:
            print("Not a valid calendar object resource path")
            returnValue(None)
        homeName = pathbits[3]
        calendarName = pathbits[4]
        resourceName = pathbits[5]
        rows = yield self.getData(txn, homeName, calendarName, resourceName)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, homeName, calendarName, resourceName):
        ch = schema.CALENDAR_HOME
        cb = schema.CALENDAR_BIND
        co = schema.CALENDAR_OBJECT
        return self.getEventData(
            txn,
            (
                ch.OWNER_UID == Parameter("HOME")).And(
                cb.CALENDAR_RESOURCE_NAME == Parameter("CALENDAR")).And(
                co.RESOURCE_NAME == Parameter("RESOURCE")
            ),
            {"HOME": homeName, "CALENDAR": calendarName, "RESOURCE": resourceName}
        )

class EventsByContent(EventDetails):

_name = "Get Event Data by Searching its Text Data"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("Search for: ")
        rows = yield self.getData(txn, uid)
        if rows:
            for result in rows:
                yield self.printEventDetails(txn, result)
        else:
            print("Could not find icalendar data")

def getData(self, txn, text):
        co = schema.CALENDAR_OBJECT
        return self.getEventData(txn, (co.ICALENDAR_TEXT.Contains(Parameter("TEXT"))), {"TEXT": text})

class EventsInTimerange(Cmd):

_name = "Get Event Data within a specified time range"

@inlineCallbacks
    def doIt(self, txn):

uid = raw_input("Owner UID/Name: ")
        start = raw_input("Start Time (UTC YYYYMMDDTHHMMSSZ or YYYYMMDD): ")
        if len(start) == 8:
            start += "T000000Z"
        end = raw_input("End Time (UTC YYYYMMDDTHHMMSSZ or YYYYMMDD): ")
        if len(end) == 8:
            end += "T000000Z"

try:
            start = DateTime.parseText(start)
        except ValueError:
            print("Invalid start value")
            returnValue(None)
        try:
            end = DateTime.parseText(end)
        except ValueError:
            print("Invalid end value")
            returnValue(None)
        timerange = caldavxml.TimeRange(start=start.getText(), end=end.getText())

home = yield txn.calendarHomeWithUID(uid)
        if home is None:
            print("Could not find calendar home")
            returnValue(None)

yield self.eventsForEachCalendar(home, uid, timerange)

@inlineCallbacks
    def eventsForEachCalendar(self, home, uid, timerange):

calendars = yield home.calendars()
        for calendar in calendars:
            if calendar.name() == "inbox":
                continue
            yield self.eventsInTimeRange(calendar, uid, timerange)

@inlineCallbacks
    def eventsInTimeRange(self, calendar, uid, timerange):

# Create fake filter element to match time-range
        filter = caldavxml.Filter(
            caldavxml.ComponentFilter(
                caldavxml.ComponentFilter(
                    timerange,
                    name=("VEVENT",),
                ),
                name="VCALENDAR",
            )
        )
        filter = Filter(filter)
        filter.settimezone(None)

matches = yield calendar.search(filter, useruid=uid, fbtype=False)
        if matches is None:
            returnValue(None)
        for name, _ignore_uid, _ignore_type in matches:
            event = yield calendar.calendarObjectWithName(name)
            ical_data = yield event.componentForUser()
            ical_data.stripStandardTimezones()

table = tables.Table()
            table.addRow(("Calendar:", calendar.name(),))
            table.addRow(("Resource Name:", name))
            table.addRow(("Resource ID:", event._resourceID))
            table.addRow(("Created", event.created()))
            table.addRow(("Modified", event.modified()))
            print("\n")
            table.printTable()
            print(ical_data.getTextWithoutTimezones())

class Purge(Cmd):

_name = "Purge all data from tables"

@inlineCallbacks
    def doIt(self, txn):

if raw_input("Do you really want to remove all data [y/n]: ")[0].lower() != 'y':
            print("No data removed")
            returnValue(None)

wipeout = (
            # These are ordered in such a way as to ensure key constraints are not
            # violated as data is removed

schema.RESOURCE_PROPERTY,

schema.CALENDAR_OBJECT_REVISIONS,

schema.CALENDAR,
            # schema.CALENDAR_BIND, - cascades
            # schema.CALENDAR_OBJECT, - cascades
            # schema.TIME_RANGE, - cascades
            # schema.TRANSPARENCY, - cascades

schema.CALENDAR_HOME,
            # schema.CALENDAR_HOME_METADATA - cascades
            schema.ATTACHMENT,

schema.ADDRESSBOOK_OBJECT_REVISIONS,

schema.ADDRESSBOOK_HOME,
            # schema.ADDRESSBOOK_HOME_METADATA, - cascades
            # schema.ADDRESSBOOK_BIND, - cascades
            # schema.ADDRESSBOOK_OBJECT, - cascades

schema.NOTIFICATION_HOME,
            schema.NOTIFICATION,
            # schema.NOTIFICATION_OBJECT_REVISIONS - cascades,
        )

for tableschema in wipeout:
            yield self.removeTableData(txn, tableschema)
            print("Removed rows in table %s" % (tableschema,))

if calendaruserproxy.ProxyDBService is not None:
            calendaruserproxy.ProxyDBService.clean()  # @UndefinedVariable
            print("Removed all proxies")
        else:
            print("No proxy database to clean.")

fp = FilePath(config.AttachmentsRoot)
        if fp.exists():
            for child in fp.children():
                child.remove()
            print("Removed attachments.")
        else:
            print("No attachments path to delete.")

@inlineCallbacks
    def removeTableData(self, txn, tableschema):
        yield Delete(
            From=tableschema,
            Where=None  # Deletes all rows
        ).on(txn)

class DBInspectService(WorkerService, object):
    """
    Service which runs, exports the appropriate records, then stops the reactor.
    """

def __init__(self, store, options, reactor, config):
        super(DBInspectService, self).__init__(store)
        self.options = options
        self.reactor = reactor
        self.config = config
        self.commands = []
        self.commandMap = {}

def doWork(self):
        """
        Start the service.
        """

# Register commands
        self.registerCommand(TableSizes)
        self.registerCommand(CalendarHomes)
        self.registerCommand(CalendarHomesSummary)
        self.registerCommand(Calendars)
        self.registerCommand(CalendarsByOwner)
        self.registerCommand(Events)
        self.registerCommand(EventsByCalendar)
        self.registerCommand(Event)
        self.registerCommand(EventsByUID)
        self.registerCommand(EventsByName)
        self.registerCommand(EventsByOwner)
        self.registerCommand(EventsByOwnerCalendar)
        self.registerCommand(EventsByPath)
        self.registerCommand(EventsByContent)
        self.registerCommand(EventsInTimerange)
        self.doDBInspect()

return succeed(None)

def postStartService(self):
        """
        Don't quit right away
        """
        pass

def registerCommand(self, cmd):
        self.commands.append(cmd.name())
        self.commandMap[cmd.name()] = cmd

@inlineCallbacks
    def runCommandByPosition(self, position):
        try:
            yield self.runCommandByName(self.commands[position])
        except IndexError:
            print("Position %d not available" % (position,))
            returnValue(None)

@inlineCallbacks
    def runCommandByName(self, name):
        try:
            yield self.runCommand(self.commandMap[name])
        except IndexError:
            print("Unknown command: '%s'" % (name,))

@inlineCallbacks
    def runCommand(self, cmd):
        txn = self.store.newTransaction()
        try:
            yield cmd().doIt(txn)
            yield txn.commit()
        except Exception, e:
            traceback.print_exc()
            print("Command '%s' failed because of: %s" % (cmd.name(), e,))
            yield txn.abort()

def printCommands(self):

print("\n<---- Commands ---->")
        for ctr, name in enumerate(self.commands):
            print("%d. %s" % (ctr + 1, name,))
        if self.options["purging"]:
            print("P. Purge\n")
        print("Q. Quit\n")

@inlineCallbacks
    def doDBInspect(self):
        """
        Poll for commands, stopping the reactor when done.
        """

while True:
            self.printCommands()
            cmd = raw_input("Command: ")
            if cmd.lower() == 'q':
                break
            if self.options["purging"] and cmd.lower() == 'p':
                yield self.runCommand(Purge)
            else:
                try:
                    position = int(cmd)
                except ValueError:
                    print("Invalid command. Try again.\n")
                    continue

yield self.runCommandByPosition(position - 1)

self.reactor.stop()

def stopService(self):
        """
        Stop the service.  Nothing to do; everything should be finished by this
        time.
        """
        # TODO: stopping this service mid-export should really stop the export
        # loop, but this is not implemented because nothing will actually do it
        # except hitting ^C (which also calls reactor.stop(), so that will exit
        # anyway).

def main(argv=sys.argv, stderr=sys.stderr, reactor=None):
    """
    Do the export.
    """
    if reactor is None:
        from twisted.internet import reactor
    options = DBInspectOptions()
    options.parseOptions(argv[1:])

def makeService(store):
        return DBInspectService(store, options, reactor, config)
    utilityMain(options['config'], makeService, reactor, verbose=options['debug'])

if __name__ == '__main__':
    main()