~pqm-dev/pqm/trunk

#!/usr/bin/env python

# -*- mode: python; coding: utf-8 -*-

# vim:smartindent cinwords=if,elif,else,for,while,try,except,finally,def,class:ts=4:sts=4:sta:et:ai:shiftwidth=4

#

# arch-tag: Simple patch queue manager for tla

# Copyright © 2003,2004 Colin Walters <walters@verbum.org>

# Copyright ©  2004 Canonical Ltd.

#   Author: Robert Collins <robertc@robertcollins.net>

# Copyright © 2003, 2005 Walter Landry

# 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 2 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 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

import os,sys

try:

    version_info = sys.version_info

except AttributeError:

    version_info = 1, 5 # 1.5 or older

REINVOKE = "__PQM_REINVOKE"

NEED_VERS = (2, 4)

KNOWN_PYTHONS = ('python2.4', 'python2.5')

if version_info < NEED_VERS:

    if not os.environ.has_key(REINVOKE):

        # mutating os.environ doesn't work in old Pythons

        os.putenv(REINVOKE, "1")

        for python in KNOWN_PYTHONS:

            try:

                os.execvp(python, [python] + sys.argv)

            except OSError:

                pass

    sys.stderr.write("error: cannot find a suitable python interpreter")

    sys.stderr.write("  (need %d.%d or later)" % NEED_VERS)

    sys.exit(1)

if hasattr(os, "unsetenv"):

    os.unsetenv(REINVOKE)

import string, stat, re, glob, getopt, time, traceback, gzip, getpass

import smtplib

import logging, logging.handlers

import pqm

from pqm import *

from pqm.PQMConfigParser import ConfigParser

from pqm.commandline import parse_command_line

from pqm.core import get_script_queue, PatchQueueManager

from pqm.errors import PQMCmdFailure, PQMException

from pqm.lockfile import LockFile

from pqm.script import Command

from pqm.queue.email import read_email

def runtla_internal(sender, cmd, *args):

    return apply(popen_noshell, [arch_path, cmd] + list(args))

def runtla(sender, cmd, *args):

    (status, msg, output) = apply(runtla_internal, [sender, cmd] + list(args))

    if not ((status is None) or (status == 0)):

        raise PQMTlaFailure(sender, ["VCS command %s %s failed (%s): %s" % (cmd, args, status, msg)] + output)

    return output

def do_read_mode(logger, options, mail_reply, mail_server, from_address, fromaddr):

    sender = None

    try:

        (sender, subject, msg, sig) = read_email(logger)

        if options.verify_sigs:

            sigid, siguid = verify_sig(

                sender, msg, sig, 1, logger, options.keyring)

            open(transaction_file, 'a').write(sigid + '\n')

        fname = 'patch.%d' % (time.time())

        logger.info('new patch ' + fname)

        f = open('tmp.' + fname, 'w')

        f.write('From: ' + sender + '\n')

        f.write('Subject: ' + subject + '\n')

        f.write(string.join(re.split('\r?\n', msg), '\n')) # canonicalize line endings

        f.close()

        os.rename('tmp.' + fname, fname)

    except:

        if sender and mail_reply:

            server = smtplib.SMTP(mail_server)

            tb=string.join(traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback), '')

            server.sendmail(from_address, [sender], 'From: %s\r\nTo: %s\r\nSubject: error processing requests\r\n\r\n' % (fromaddr, sender) + 'An error was encountered:\n' + tb)

            server.quit()

        logger.exception("Caught exception")

        sys.exit(1)

    sys.exit(0)

arch_path = 'baz'

arch_impl = None

logfile_name = 'pqm.log'

default_mail_log_level = logging.ERROR

precommit_hook = []

(options, args) = parse_command_line(sys.argv[1:])

if options.show_version:

    print "pqm %s" % pqm.__version__

    sys.exit(0)

logger = logging.getLogger("pqm")

# TODO: move the logging confuration somewhere else.

logger.setLevel(logging.DEBUG)

stderr_handler = logging.StreamHandler(sys.stderr)

stderr_handler.setLevel(options.loglevel)

stderr_handler.setFormatter(logging.Formatter(fmt="%(name)s [%(thread)d] %(levelname)s: %(message)s"))

logger.addHandler(stderr_handler)

if not (options.read_mode or options.run_mode):

    logger.error("Either --read or --run must be specified")

    sys.exit(1)

configp = ConfigParser()

logger.debug("Reading config files: %s" % (options.configfile_names,))

configp.read(options.configfile_names)

if configp.has_option('DEFAULT', 'arch_path'):

    arch_path = configp.get('DEFAULT', 'arch_path')

elif configp.has_option('DEFAULT', 'tlapath'):

    logger.warn("Option 'tlapath' is deprecated")

    arch_path = configp.get('DEFAULT', 'tlapath')

if os.access(arch_path, os.X_OK):

    logger.error("Can't execute \"%s\", please fix arch_path" % (arch_path,))

    sys.exit(1)

# ugly transitional code

pqm.logger = logger

if configp.has_option('DEFAULT', 'arch_impl'):

    impl = configp.get('DEFAULT', 'arch_impl')

    if impl == 'tla':

        arch_impl = TlaHandler()

    elif impl == 'arx':

        arch_impl = ArXHandler()

    elif impl == 'baz':

        arch_impl = Baz1_1Handler()

    elif impl == 'baz1.0':

        arch_impl = Baz1_0Handler()

    else:

        logger.error("Unknown arch_impl \"%s\"" % (impl,))

        sys.exit(1)

# FIXME: move this into a nicer place.

Command.arch_impl = arch_impl

Command.arch_path = arch_path

pqm.gpgv_path = configp.get_option('DEFAULT', 'gpgv_path', 'gpgv')

# The command line paramter overrides the setting in the config file.

if options.verify_sigs:

    options.verify_sigs = configp.get_boolean_option(

        'DEFAULT', 'verify_sigs', True)

if options.queuedir:

    queuedir = options.queuedir

else:

    queuedir = get_queuedir(configp, logger, args)

queuedir=os.path.abspath(queuedir)

manager = PatchQueueManager(queuedir, configp, options, logger)

if manager.from_address is None:

    logger.error("No from_address specified")

    sys.exit(1)

# Still temporary hack.  Tim Penhey 2008-05-29

pqm.pqm_subdir = manager.control_dir

# ugly transitional code

pqm.logger = logger

pqm.workdir = manager.work_dir

pqm.runtla = runtla

pqm.precommit_hook = precommit_hook

if not configp.has_option('DEFAULT', 'dont_set_home'):

    os.environ['HOME'] = queuedir

if not options.keyring and options.verify_sigs:

    if configp.has_option('DEFAULT', 'keyring'):

        options.keyring = configp.get('DEFAULT', 'keyring')

    else:

        logger.error("No keyring specified on command line or in config files.")

        sys.exit(1)

if options.verify_sigs and not os.access(options.keyring, os.R_OK):

    logger.error("Couldn't access keyring %s" % (options.keyring,))

    sys.exit(1)

manager.make_directories()

os.chdir(queuedir)

rev_optionhandler = pqm.BranchSpecOptionHandler(configp, queuedir=queuedir)

if len(rev_optionhandler._specs) == 0:

    logger.error("No branches to manage!")

    sys.exit(1)

for spec in rev_optionhandler._specs:

    logger.info("managing branch(s): " + spec)

if configp.has_option('DEFAULT', 'logfile'):

    logfile_name = configp.get('DEFAULT', 'logfile')

if not options.no_log:

    if not os.path.isabs(logfile_name):

        logfile_name = os.path.join(manager.control_dir, logfile_name)

    logger.debug("Adding log file: %s" % logfile_name)

    filehandler = logging.FileHandler(logfile_name)

    if options.loglevel >= logging.WARN:

        filehandler.setLevel(logging.INFO)

    else:

        filehandler.setLevel(logging.DEBUG)

    logger.addHandler(filehandler)

    filehandler.setFormatter(logging.Formatter(

            fmt="%(asctime)s %(name)s [%(thread)d] %(levelname)s: %(message)s",

            datefmt="%b %d %H:%M:%S"))

if not options.debug_mode:

    # Don't log to stderr past this point

    logger.removeHandler(stderr_handler)

transaction_file = os.path.join(queuedir, 'transactions-completed')

if os.access(transaction_file, os.R_OK):

    lines = open(transaction_file).readlines()

    for line in lines:

        pqm.used_transactions[line[0:-1]] = 1

if options.read_mode:

    do_read_mode(logger, options, manager.mail_reply, manager.mail_server,

                 manager.from_address, manager.nice_from_address)

assert(options.run_mode)

script_queue = get_script_queue(

    queuedir, logger, rev_optionhandler, configp, options, manager)

manager.run(script_queue)

logger.info("main thread exiting...")

sys.exit(0)