1

#!/usr/bin/env python2.5

     2

     3

"""

     4

    Tool for accessing the search index

     5

"""

     6

     7

# XXX: fix path

     8

import sys; sys.path.insert(0, '.'); sys.path.insert(0, '..')

     9

    10

import datetime, pytz

    11

    12

# configuration and the LogSearchIndex module

    13

import config, log_search, channels

    14

    15

def _open_index (options, open_mode) :

    16

    """

    17

        Opens the LogSearchIndex

    18

    """

    19

    20

    return log_search.LogSearchIndex(config.LOG_CHANNELS, options.index_path, open_mode)

    21

    22

    23

def _open_index_and_channel (options, channel_name, open_mode) :

    24

    """

    25

        Opens+returns a LogSearchIndex and a LogChannel

    26

    """

    27

    28

    # open the LogSearchIndex

    29

    index = _open_index(options, open_mode)

    30

    31

    # open the channel

    32

    channel = config.LOG_CHANNELS.lookup(channel_name)

    33

    34

    # return

    35

    return index, channel

    36

    37

def _load_channel_date (index, options, channel, date) :

    38

    """

    39

        Loads the logs for the given date from the channel's LogSource into the given LogSearchIndex

    40

    """

    41

    42

    if not options.quiet :

    43

        print "%s %s..." % (channel.id, date.strftime(channel.source.filename_fmt)),

    44

    45

    try :

    46

        # load lines for date

    47

        lines = channel.source.get_date(date)

    48

    49

    except Exception, e :

    50

        if not options.skip_missing :

    51

            raise

    52

    53

        if not options.quiet :

    54

            print "Skipped: %s" % (e, )

    55

    56

    else :

    57

        # insert -> count

    58

        count = index.insert(channel, lines)

    59

    60

        if not options.quiet :

    61

            print "OK: %d lines" % count

    62

    89

class CommandError (Exception) :

    90

    """

    91

        Error with command-line arguments

    92

    """

    93

    94

    pass

    95

    96

def cmd_create (options) :

    97

    """

    98

        Creates a new index

    99

    """

   100

   101

    # open index

   102

    index = _open_index(options, 'c' if not options.force else '*')

   103

   104

    # that's all

   105

    pass

   106

   107

def cmd_load (options, channel_name, *dates) :

   108

    """

   109

        Loads the logs for a specific channel for the given dates (in terms of the channe logs' timezone) into the index

   110

    """

   111

   112

    # open index/channel

   113

    index, channel = _open_index_and_channel(options, channel_name, 'c' if options.create else 'a')

   114

   115

    # handle each date

   118

        try :

   123

            if options.skip_missing :

   125

   126

            else :

   127

                raise

   128

   132

   133

def cmd_load_month (options, channel_name, *months) :

   134

    """

   135

        Loads the logs for a specific channel for the given months (in terms of the channel's timezone) into the index

   136

    """

   137

   138

    # open index/channel

   139

    index, channel = _open_index_and_channel(options, channel_name, 'c' if options.create else 'a')

   140

   141

    # handle each date

   144

        try :

   150

            if options.skip_missing :

   152

                continue

   153

   154

            else :

   155

                raise

   156

   157

        # get the set of days

   158

        days = list(channel.source.get_month_days(month))

   159

   160

        print "Loading %d days of logs:" % (len(days))

   161

   162

        # load each day

   163

        for date in days :

   164

            # convert to datetime

   165

            dt = datetime.datetime.combine(date, datetime.time(0)).replace(tzinfo=channel.source.tz)

   166

   167

            # load

   168

            _load_channel_date(index, options, channel, dt)

   169

   170

def cmd_search (options, channel_name, query) :

   171

    """

   172

        Search the index for events on a specific channel with the given query

   173

    """

   174

   175

    # sanity-check

   177

        raise Exception("--create doesn't make sense for 'search'")

   178

   179

    # open index/channel

   180

    index, channel = _open_index_and_channel(options, channel_name, 'r')

   181

   182

    # search

   183

    lines = index.search_simple(channel, query)

   184

   210

   211

def cmd_help (options, *args) :

   212

    """

   213

        Help about commands

   214

    """

   215

   216

    import inspect

   217

   218

    # general help stuff

   219

    options._parser.print_help()

   220

   221

    # specific command?

   222

    if args :

   223

        # the command name

   224

        command, = args

   225

   226

        # XXX: display info about specific command

   227

        xxx

   228

   229

    # general

   230

    else :

   231

        print

   232

        print "Available commands:"

   233

   234

        # build list of all cmd_* objects

   235

        cmd_objects = [(name, obj) for name, obj in globals().iteritems() if name.startswith('cmd_') and inspect.isfunction(obj)]

   236

   237

        # sort alphabetically

   238

        cmd_objects.sort()

   239

   240

        # iterate through all cmd_* objects

   241

        for cmd_func_name, cmd_func in cmd_objects :

   242

            # remove cmd_ prefix

   243

            cmd_name = cmd_func_name[4:]

   244

   245

            # inspect

   246

            cmd_args, cmd_varargs, cmd_varkw, cmd_default = inspect.getargspec(cmd_func)

   247

            cmd_doc = inspect.getdoc(cmd_func)

   248

   249

            # remove the "options" arg

   250

            cmd_args = cmd_args[1:]

   251

   252

            # display

   253

            print "\t%10s %-30s : %s" % (cmd_name, inspect.formatargspec(cmd_args, cmd_varargs, None, cmd_default), cmd_doc)

   254

   255

def main (argv) :

   256

    """

   257

        Command-line main, with given argv

   258

    """

   259

   260

    from optparse import OptionParser

   261

   262

    # define parser

   263

    parser = OptionParser(

   264

        usage           = "%prog [options] <command> [ ... ]",

   265

        add_help_option = False,

   266

    )

   267

   268

    # define command-line arguments

   269

    parser.add_option('-h', "--help",           dest="help",            help="Show this help message and exit",     action="store_true")

   270

    parser.add_option('-F', "--formatter",      dest="formatter_name",  help="LogFormatter to use",                 metavar="FMT",  type="choice", default="irssi",

   271

        choices=[fmt_name for fmt_name in config.LOG_FORMATTERS.iterkeys()])

   272

   273

    parser.add_option('-I', "--index",          dest="index_path",      help="Index database path",                 metavar="PATH", default="logs/index")

   274

    parser.add_option('-Z', "--timezone",       dest="tz_name",         help="Timezone for output",                 metavar="TZ",   default="UTC")

   275

    parser.add_option('-f', "--force",          dest="force",           help="Force dangerous operation",           action="store_true")

   276

    parser.add_option(      "--create",         dest="create",          help="Create index database",               action="store_true")

   277

    parser.add_option(      "--skip-missing",   dest="skip_missing",    help="Skip missing logfiles",               action="store_true")

   278

    parser.add_option(      "--quiet",          dest="quiet",           help="Supress status messages",             action="store_true")

   279

   280

    # parse

   281

    options, args = parser.parse_args(argv[1:])

   282

   283

    # postprocess stuff

   284

    options._parser = parser

   285

    options.tz = pytz.timezone(options.tz_name)

   286

    options.formatter = config.LOG_FORMATTERS[options.formatter_name](options.tz, "%H:%M:%S", None, None)

   287

   288

    # special-case --help

   289

    if options.help :

   290

        return cmd_help(options, *args)

   291

   292

    # must have at least the command argument

   293

    if not args :

   294

        raise CommandError("Missing command")

   295

   296

    # pop command

   297

    command = args.pop(0)

   298

   299

    # get func

   300

    func = globals().get('cmd_%s' % command)

   301

   302

    # unknown command?

   303

    if not func :

   304

        raise CommandError("Unknown command: %s" % command)

   305

   306

    # call

   307

    func(options, *args)

   308

   309

if __name__ == '__main__' :

   310

    try :

   311

        main(sys.argv)

   312

        sys.exit(0)

   313

   314

    except CommandError, e :

   315

        print e

   316

        sys.exit(1)

   317