path: root/scripts/tatt

#!/usr/bin/env python

# Global Modules
from subprocess import *
import sys
import re
import os

from tatt.gentooPackage import gentooPackage as gP
import tatt.packageFinder as packageFinder
from tatt.scriptwriter import writeusecombiscript as writeUSE
from tatt.scriptwriter import writerdepscript as writeRdeps
from tatt.scriptwriter import writesucessreportscript as writeSuccess
from tatt.scriptwriter import writecommitscript as writeCommit
from tatt.scriptwriter import writeCleanUpScript as writeCleanup
from tatt.tattConfig import tattConfig as tattConfig
from tatt.job import job as job

##### Generate a global config obj, reading from ~/.tatt #####
config = tattConfig()

######### Main program starts here ###############

### USAGE and OPTIONS ###
from optparse import OptionParser

parser=OptionParser()
parser.add_option("-d", "--depend",
                  help="Determine stable rdeps",
                  dest="depend",
                  action="store_true",
                  default = False)
parser.add_option("-u", "--use", "--usecombis",
                  help="Determine use flag combinations",
                  dest="usecombi",
                  action="store_true",
                  default = False)
parser.add_option("-f", "--file", 
                  help="Input File containing packages",
                  dest="infile",
                  action="store"
                  )
parser.add_option("-j", "--jobname",
                  help="name for the job, prefix of output files",
                  dest="jobname",
                  action="store")
parser.add_option("-b", "--bug",
                  help="do the full program for a given stable request bug",
                  dest="bugnum",
                  # type="int",
                  # We could test this here, but in most cases the bugnumber
                  # is actually used as a string, so we validate further down
                  # and leave it as a string
                  action="store")
parser.add_option("-s", "--success",
		  help="Comment that the program was successfully tested",
                  dest="succbugnum",
		  action="store")
parser.add_option("-r", "--resolve",
		  help="Resolve the given bugnumber, needs a message",
                  dest="resolvenum",
		  action="store")
parser.add_option("-c", "--close",
		  help="Resolve the given bugnumber with closing it, needs to be combined with -r",
                  dest="close",
		  action="store_true")
parser.add_option("-m", "--message",
		  help="Message for bug resolution.",
                  dest="resolvemessage",
		  action="store")
parser.add_option("-v", "--verbose",
		  help="Print informative output.",
                  dest="verbose",
		  action="store_true",
                  default = False)

(options,args) = parser.parse_args()

## Messing with the configuration:
# Save verbosity level
config['verbose']=options.verbose
# Normalize the template dir:
config['template-dir']=os.path.abspath(config['template-dir'])+os.sep
# If given, test if the bugnumber represents an int
try:
    int(options.bugnum)
except ValueError:
    print ("The bugnumber you gave with -b should be an integer.")
    exit(1)
except TypeError:
    # This occurs if bugnum is None, that is, -b was not given
    pass

## If safedir is set, check for the current directory
if config['safedir'] != "":
    if os.getcwd().find(config['safedir']) == -1:
        # Safedir not found
        print ("Your safedir variable is set to '" + config['safedir'] + "',")
        print ("but you are in " + os.getcwd())
        print ("Exiting.")
        exit (1)

## Checking for root, tatt should be run as a user, I guess.
## Remove on occasion.
if (Popen(['whoami'], stdout=PIPE).communicate()[0].rstrip() == 'root'):
    isroot=True
else:
    print("You're not root!")
    isroot=False

## -s and a bugnumber was given ?
if options.succbugnum:
    print("Reporting success for bug number " + options.succbugnum)
    retcode = call(['bugz', 'modify', options.succbugnum, '-c', config['successmessage']])
    if retcode == 0:
        print("Success!");
        exit (0)
    else:
        print("Failure commenting on Bugzilla")
        exit(1)

# get a job object to save things to
myJob = job()

## If -f and a filename have been given:
if options.infile: 
    try:
        packfile=open(options.infile, 'r')
    except IOError:
        print("Given filename not found !")
        exit(1)
    packraw = packfile.read()
    packfile.close()
    myJob.packageList = packageFinder.findPackages(packraw, re.compile(config['atom-regexp']))

## -b and a bugnumber was given ?
if options.bugnum:
    print("Bugnumber:  " + options.bugnum)
    myJob.bugnumber=options.bugnum
    p1 = Popen(['bugz', 'get', myJob.bugnumber, '-n'], stdout=PIPE)
    # Instead we now capture everything:
    bugraw = p1.communicate()[0]
    bugtitle = [l for l in bugraw.splitlines() if 'Title' in l][0]
    if re.search('KEYWORDREQ', bugraw):
        # This is a keywording bug:
        print ("Keywording bug detected.")
        myJob.type="keyword"
    elif re.search('STABLEREQ', bugraw):
        # Stablebug
        print ("Stabilization bug detected.")
        myJob.type="stable"
    else:
        print ("Could not detect bug's type, is the 'Keywords' field set?")
        exit(1)
    # If myJob.packageList is still empty we search in the bug-title
    if myJob.packageList==None:
        myJob.packageList = packageFinder.findPackages(bugtitle, re.compile(config['atom-regexp']))

# joint code for -f and -b
##########################

if not myJob.packageList==None:
    ## Assigning jobname
    if options.jobname:
        myJob.name = options.jobname
    elif options.infile:
        myJob.name = options.infile
    else:
        myJob.name = myJob.packageList[0].packageName()
    print ("Jobname: " + myJob.name)
    ## Determine jobtype
    
    for p in myJob.packageList:
        print("Found the following package atom : " + p.packageString())

    # Unmasking:
    if isroot:
        # If we are root, then we can write to package.keywords
        try:
            unmaskfile=open(config['unmaskfile'], 'r+')
        except IOError:
            # create an empty file, this should be beautified
            unmaskfile=open(config['unmaskfile'], 'w')
            unmaskfile.write(" ")
            unmaskfile.close()
            unmaskfile=open(config['unmaskfile'], 'r+')

        unmaskfileContent = unmaskfile.read()
        for p in myJob.packageList:
            # Test if unmaskfile already contains the atom
            if re.search(p.packageString(), unmaskfileContent):
                print (p.packageString() + " already in "+config['unmaskfile'])
            else:
                unmaskfile.write(p.packageString())
                if myJob.type=="stable":
                    unmaskfile.write("\n")
                elif myJob.type=="keyword":
                    unmaskfile.write(" ** \n")
                else:
                    print ("Uh Oh, no job.type? Tell tomka@gentoo.org to fix this!")
                    unmaskfile.write("\n")
                print ("Unmasked " + p.packageString()+ " in "+config['unmaskfile'])
        unmaskfile.close()
    else:
        print ("You are not root, your unmaskstring would be:")
        print ("\n".join([p.packageString() for p in myJob.packageList]) + "\n")
    ## Write the scripts
    writeUSE(myJob, config)
    writeRdeps(myJob, config)
    writeCleanup (myJob, config)
    ## Config and Successscript can only be written if we have a bugnumber
    if myJob.bugnumber:
        writeSuccess(myJob, config)
        writeCommit(myJob, config)
    exit (0)

# Code for resolving bugs (-r and -m)
#####################################
if options.resolvenum:
    if not options.resolvemessage:
        print("Please call with a message per -m")
        exit (1)
    print("Resolving bug number " + options.resolvenum)
    calllist = ['bugz', 'modify', options.resolvenum, '-c', options.resolvemessage, '--remove-cc', config['arch']+"@gentoo.org"]
    if options.close:
        calllist = calllist + ['--fixed']
    retcode = call(calllist)
    if retcode == 0:
        print("Success!");
        exit (0)
    else:
        print("Failure accessing bugzilla.")
        exit(1)


## If we arrive here then a package atom should be given
try:
    myJob.packageList=[gP(args[0])]
    myJob.name=myJob.packageList[0].packageName()
except IndexError:
    print("Please call with package atom as argument")
    exit (1)

if options.depend:
    writeRdeps(myJob, config)

if options.usecombi:
    writeUSE(myJob, config)

## That's all folks ##