response-cleanup

#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''Response Project - Cleanup'''

# Copyright (C) 2009-2010 John Feuerstein <john@feurix.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

from globals import __author__, __copyright__, __license__, __version__

import os
import signal
import sys
import logger
import exception

from datetime import datetime, timedelta

from config import Config
from pidfile import PidFile
from optparse import OptionParser

# Option parsing
version = '%prog version ' + __version__
usage = 'Usage: %prog [options]'

parser = OptionParser(usage=usage, version=version)

# Cleanup operations (all uppercase)
parser.add_option('-A', '--all', action='store_true', dest='all_at_once',
        help='perform all of the following cleanup operations in one go',)
parser.add_option('-D', '--disable-expired-configs', action='store_true',
        dest='disable_expired_configs',
        help='disable all response configs that have expired',)
parser.add_option('-O', '--delete-old-response-records', action='store_true',
        dest='delete_old_response_records',
        help='delete old response records that were not hit for a long time',)
parser.add_option('-U', '--delete-unused-response-records',
        action='store_true',
        dest='delete_records_of_disabled_configs',
        help='delete all response records that belong to disabled configs',)

parser.add_option('-n', '--dry-run', action='store_true', dest='dryrun',
        help='do not execute any query, show what would have been done',)
parser.add_option('-d', '--debug', action='store_true', dest='debug',
        help='debug mode')
parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
        help='verbose mode')
parser.add_option('-q', '--quiet', action='store_true', dest='quiet',
        help='only log errors')
parser.add_option('-s', '--syslog', action='store_true', dest='syslog',
        help='log to syslog')
parser.add_option('--syslog-facility', type='string', action='store',
        dest='syslog_facility', default='MAIL',
        help='specify the syslog facility (default: MAIL)')
parser.add_option('-c', '--config', action='store', dest='config_file',
        help='specify an alternate path to the config file,     ' \
             'default: /etc/response.cfg',
        default='/etc/response.cfg')
parser.add_option('-p', '--pid-file', action='store', dest='pid_file',
        help='specify an alternate path to the pid file,     ' \
             'default: /var/run/response/cleanup.pid',
        default='/var/run/response/cleanup.pid')

(options, args) = parser.parse_args()

if options.all_at_once:
    options.disable_expired_configs = True
    options.delete_old_response_records = True
    options.delete_records_of_disabled_configs = True

if not (options.disable_expired_configs
        or options.delete_old_response_records
        or options.delete_records_of_disabled_configs):
    print('Error: Need at least one cleanup operation!\n')
    parser.print_help()
    sys.exit(1)

# Logging
log = logger.getLog(
        debug=options.debug,
        verbose=options.verbose,
        quiet=options.quiet,
        syslog=options.syslog,
        syslog_facility=options.syslog_facility,
        )

# Signal handling
def signal_handler(signum, frame):
    if signum == signal.SIGINT:
        log.warning('Received SIGINT, exiting...')
        raise exception.SignalReceived(signum, 'SIGINT')
    elif signum == signal.SIGTERM:
        log.warning('Received SIGTERM, exiting...')
        raise exception.SignalReceived(signum, 'SIGTERM')
    else:
        log.warning('Received signal number %d, exiting...' % signum)
        raise exception.SignalReceived(signum)

signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)


# Main
log.warning('%s starting up... (loglevel: %s)'
        % (parser.get_version(), logger.getLogLevelName(log)))

try:
    pid = PidFile(file=options.pid_file)
    pid.write()
except exception.PidFileError, e:
    if e.stalefile:
        log.fatal('Stale pidfile %s present.' % options.pid_file)
        log.fatal('Response-Cleanup already running?')
    else:
        log.fatal('Unable to write to pidfile %s' % options.pid_file)

    log.fatal('Exiting with errors...')
    sys.exit(1)

log.warning('Running with PID=%d' % pid.pid)

config = Config(options.config_file)
backend = config.backend.adapter(config.backend)
ret = 0

if options.dryrun:
    log.warning('DRY-RUN requested: Not performing any SQL queries!')

try:
    log.warning('Initializing...')
    try:
        log.warning('Connecting to backend...')
        connection = backend.connect()
        cursor = backend.open_cursor(connection)
    except Exception, e:
        log.error('Error initialising backend: %s' % e)
        ret = 2
        raise

    try:
        log.warning('Executing cleanup operations')

        if options.disable_expired_configs:
            log.warning('Disabling expired configs')
            date = datetime.now()
            if not options.dryrun:
                backend.disable_expired_configs(cursor, date)
                backend.commit(connection)
            log.warning('Success!')

        if options.delete_old_response_records:
            log.warning('Deleting old response records')
            date = datetime.now() - timedelta(
                    seconds=config.cleanup.timedelta)
            log.debug('Matching records with inactivity since %s' % date)
            if not options.dryrun:
                backend.delete_old_response_records(cursor, date)
                backend.commit(connection)
            log.warning('Success!')

        if options.delete_records_of_disabled_configs:
            log.warning('Deleting response records of disabled configs')
            if not options.dryrun:
                backend.delete_records_of_disabled_configs(cursor)
                backend.commit(connection)
            log.warning('Success!')

    except exception.SignalReceived, s:
        log.info('Cleanup operation received signal %d (%s)' %
                (s.signum, s.signame))
        ret = 3
        # This may be useful someday...

    except Exception, e:
        ret = 1
        log.error('Unhandled exception: %s' % e)

    finally:
        log.warning('Doing a graceful shutdown...')
        backend.close_cursor(cursor)
        backend.disconnect(connection)
        backend.close()

except Exception, e:
    ret = 1
    log.error('Catched unhandled exception: %s' % e)
finally:
    log.debug('Cleaning up...')
    pid.delete()

log.warning('Quit.')
sys.exit(ret)