import os, os.path
import logging, logging.config
import sys
import subprocess
import datetime
import time
import optparse

import string
import uuid
import re
import base64
import shutil

from jjobrun.chroot_package_installer import chrootPackageFacard as ChrootPackageInstaller
from jjobrun.chroot_script_runner import runnershell2  as runnershell


def subphandling(cmd,timeout = 10):   
    log = logging.getLogger("sub")
    process = subprocess.Popen([cmd], shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    processRc = None
    handleprocess = True
    counter = 0
    stdout = ''
    stderr = ''
    while handleprocess:
        counter += 1
        time.sleep(1)
        cout,cerr = process.communicate()
        stdout += cout
        stderr += stderr
        #log.info(cout)
        #log.warning(cerr)
        process.poll()
        processRc = process.returncode
        if processRc != None:
            break
        if counter == timeout:
            os.kill(process.pid, signal.SIGQUIT)
        if counter > timeout:
            os.kill(process.pid, signal.SIGKILL)
            processRc = -9
            break
    return (processRc,stdout,stderr)

#!/usr/bin/env python

"""This spawns a sub-shell (bash) and gives the user interactive control. The
entire shell session is logged to a file called script.log. This behaves much
like the classic BSD command 'script'.

./script.py [-a] [-c command] {logfilename}

    logfilename : This is the name of the log file. Default is script.log.
    -a : Append to log file. Default is to overwrite log file.
    -c : spawn command. Default is to spawn the sh shell.

Example:

    This will start a bash shell and append to the log named my_session.log:

        ./script.py -a -c bash my_session.log

"""

import os, sys, time, getopt
import signal, fcntl, termios, struct
import traceback
import pexpect

global_pexpect_instance = None # Used by signal handler

transtbl = string.maketrans(
          'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
          'ABCEGHJKLMNPRSTVWXYZabcdefghijkl'
        )
def exit_with_usage():

    print globals()['__doc__']
    os._exit(1)

def sigwinch_passthrough (sig, data):

    # Check for buggy platforms (see pexpect.setwinsize()).
    if 'TIOCGWINSZ' in dir(termios):
        TIOCGWINSZ = termios.TIOCGWINSZ
    else:
        TIOCGWINSZ = 1074295912 # assume
    s = struct.pack ("HHHH", 0, 0, 0, 0)
    a = struct.unpack ('HHHH', fcntl.ioctl(sys.stdout.fileno(), TIOCGWINSZ , s))
    global global_pexpect_instance
    global_pexpect_instance.setwinsize(a[0],a[1])




def jumpstrart():
    #if __name__ == "__main__":
    try:
        main()
    except SystemExit, e:
        raise e
    except Exception, e:
        print "ERROR"
        print 'sssssss',str(e)
        traceback.print_exc()
        os._exit(1)



def lsb_release():
    log = logging.getLogger("lsb_release")
    cmd = "lsb_release -a"
    processRc,stdout,stderr = subphandling(cmd,timeout = 10)
    if processRc != 0:
        log.error("'%s' returned an error" % (cmd))
        return None
    magicLines = ["Distributor ID",
        "Description",
        "Release",
        "Codename"]
    output = {}
    for line in stdout.split('\n'):
        splitline = line.strip().split(':')
        if len(splitline) <= 1:
            continue
        if splitline[0] in magicLines:
            value = splitline[1].strip()
            output[splitline[0]] = value
    #log.info(output)
    
    return output

class jobPartRun:
    def __init__(self, shell="/bin/bash"):
        self.log = logging.getLogger("jobPartRun")
        self.shell = shell
        
        
        
    def do_something(self,prefix):
        #imput = self.p.read()
        imput = self.p.before
        striped = imput.strip()
        if len(striped) > 0:
            self.log.info("%s=%s" % (prefix,imput.strip()))
        
    def endofline(self):
        #imput = self.p.read()
        imput = self.p.before
        striped = imput.strip()
        if len(striped) > 0:
            self.log.info("endofline=%s" % (imput.strip()))
        #infomration = self.p.read()
    
    
    def getArtifacts(self,jobpart,env):
        if not "artifacts" in jobpart.keys():
            self.log.debug("No artifacts in chroot script so no chroot artifacts")
            return True
            RawartifactsList = list(jobpart["artifacts"])
        if not "CHROOT" in env.keys():
            self.log.debug("No CHROOT variable, so no chroot artifacts")
            return True
        prefix =  env["CHROOT"]
        RawartifactsList = list(jobpart["artifacts"])
        rc = 0
        for artifact in RawartifactsList:
            directory = os.path.dirname(artifact)
            src = "%s/%s" %( prefix,artifact)
            dest = artifact
            self.log.info("Copying directory=%s,src=%s,dest=%s" % (directory,src,dest))
            shutil.copyfile(src, dest)
        return True
    
    def _installPackages(self,pi,depnedacylist):
        if len(depnedacylist) == 0:
            self.log.info("no packages to install")
            return True
        initok = pi.initialise()
        self.log.info("2222")
        if  initok == False:
            self.log.info("INITIALISATION FAILED")
            return False
        self.log.info("bbb")
        initok = pi.updatePackages()
        if  initok == False:
            return False
        self.log.info("aaa")
        initok = pi.installPackages(depnedacylist)
        if  initok == False:
            return False
        self.log.info("333")
        pi.finalise()
        return True
    
            
    def packagesDebain(self,jobpart,env):
        self.log.info("packagesDebain(%s,%s)" % (jobpart,env))
        depnedacylist = []
        if "shell" in jobpart.keys():
            
            if "dependancies" in jobpart["shell"].keys():
                
                if "Debian" in jobpart["shell"]["dependancies"].keys():
                    self.log.info("found the answer")
                    depnedacylist = list(jobpart["shell"]["dependancies"]["Debian"])
        if not 'CHROOT' in env.keys():
            return True
        chrootdir = env['CHROOT']
        cmd = "/usr/sbin/chroot %s" % (chrootdir)
        pi = ChrootPackageInstaller(command = cmd,enviroment = env, packaging = "deb")
        return self._installPackages(pi,depnedacylist)
        
    def packagesScientific(self,jobpart,env):
        self.log.info("packagesScientific(%s,%s)" % (jobpart,env))
        depnedacylist = []
        if "shell" in jobpart.keys():
            
            if "dependancies" in jobpart["shell"].keys():
                
                if "Scientific" in jobpart["shell"]["dependancies"].keys():
                    self.log.info("found the answer")
                    depnedacylist = list(jobpart["shell"]["dependancies"]["Scientific"])
        if not 'CHROOT' in env.keys():
            return True
        chrootdir = env['CHROOT']
        cmd = "/usr/sbin/chroot %s /bin/sh" % (chrootdir)
        pi = ChrootPackageInstaller(command = cmd,enviroment = env,packaging = "rpm")
        return self._installPackages(pi,depnedacylist)
        
        
        
    def packages(self,jobpart,env):
        #self.log.error("packages")
        release =  lsb_release()
        self.log.error("Distributor=%s" % (release["Distributor ID"]))
        done = False
        if release["Distributor ID"] == "Debian":
            self.packagesDebain(jobpart,env)
            done = True
        if release["Distributor ID"] == "Scientific":
            self.packagesScientific(jobpart,env)
            done = True
        return done            
        
        
    def executabingo(self,jobpart,env = {}):
        #self.log.error("executabingo")
        inputenv = os.environ
        inputenv.update(env)
        output = {"rc" :  255 , "env" : {}}
        knownKeys = set(inputenv)
        env_ignored = set(["PATH","SHLVL","OLDPWD",]).union(set(env.keys()))
        
        if not "flags" in jobpart.keys():
            self.log.error("no flags specified")
            return output
        
        if not "script" in jobpart.keys():
            sel.log.error("no script specified")
            return output
        self.packages(jobpart,env)
        command = "/bin/bash"
        allfliages =  jobpart["flags"]
        self.log.error("flags=%s" % (allfliages))
        if "chroot" in allfliages:
            if not "CHROOT" in inputenv.keys():
                self.log.error("no CHROOT enviroment_valiable set")
                return output
            chootdir = inputenv["CHROOT"]
            command = "%s %s /bin/bash"  % ("/usr/sbin/chroot" , chootdir)
        self.log.error("command=%s" % (command))
        #chroot /workspace/docbook-production/chroot/ /bin/bash
        sr = runnershell(command=command)
        rc = sr.initialise()
        if rc != True:
            sel.log.error("failed to init CHROOT")
            return output
        rc = sr.setEnv(env)
        if rc != True:
            sel.log.error("failed to set env in CHROOT")
            return output
        # Now load script
        script = "%s/%s" % (os.path.dirname(os.path.realpath(__file__)),jobpart["script"])
        initialEnv = sr.getEnv()
        #self.log.info("initialEnv '%s'" % (initialEnv))
        rc = sr.runscript(script)
        foundEnv = {}
        if rc != 0:
            self.log.info("runscript rc '%s'" % (rc))
        else:
            self.log.info("Updating env")
            afterEnv = sr.getEnv()
            self.log.debug("initialEnv '%s'" % (initialEnv))
            self.log.debug("afterEnv '%s'" % (afterEnv))
            keysInitial = set(initialEnv.keys()).difference()
            keysFinal = set(afterEnv.keys()).difference()
            keysnew = keysFinal.difference(keysInitial)
            
            for key in keysnew:
                value = afterEnv[key]
                self.log.info("Exported '%s=%s'" % (key,value))
                foundEnv[key] = value
        returnCode = sr.finalise()
        #self.log.info("finalise rc '%s'" % (returnCode))
        return {"rc" :  rc , "env" : foundEnv}

def runJob (jobname):
    log = logging.getLogger("runJob")
    mappings = {
        "GenChroot.SL-6X" : ["transfer/GenChroot.SL-6X.sh"],

        "vmcatcher-scientific-6-trunk" : ["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/vmcatcher-scientific-6-trunk.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcatcher-scientific-6-trunk-test" :["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/vmcatcher-scientific-6-trunk-test.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcatcher-scientific-6-prod-test" : ["transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/vmcatcher-scientific-6-prod-test.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcatcher_eventHndlExpl_ON-scientific-6-prod" : ["transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/vmcatcher_eventHndlExpl_ON-scientific-6-prod-part-01.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcatcher_eventHndlExpl_ON-scientific-6-trunk" : ["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/vmcatcher_eventHndlExpl_ON-scientific-6-trunk.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "smimeX509validation-scientific-6-trunk" :["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/smimeX509validation-scientific-6-trunk-part-02.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "smimeX509validation-scientific-6-prod" : ["transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/smimeX509validation-scientific-6-prod-part-02.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "grid-virt-sort-scientific-6-prod" : [ "transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/grid-virt-sort-scientific-6-prod.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "hepixvmitrust-scientific-6-prod" : [ "transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/hepixvmitrust-scientific-6-prod.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcaster-scientific-6-trunk" : [ "transfer/chroot-scientific-6-buildup-trunk.sh" ,
            "transfer/vmcaster-scientific-6-trunk-part-02.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "dirvacua-scientific-6-trunk" : [ "transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/dirvacua-scientific-6-trunk.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "vmcaster-scientific-6-prod" : ["transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/vmcaster-scientific-6-prod-part-02.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "chrootbuilder-scientific-6-prod" : ["transfer/chroot-scientific-6-buildup-prod.sh",
            "transfer/chrootbuilder-scientific-6-prod.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "hepixvmitrust-scientific-6-trunk" : ["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/hepixvmitrust-scientific-6-trunk.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "repo-scientific" : ["transfer/repo-scientific.sh"],
        "grid-virt-sort-scientific-6-trunk" : ["transfer/chroot-scientific-6-buildup-trunk.sh",
            "transfer/grid-virt-sort-scientific-6-trunk.sh",
            "transfer/chroot-scientific-6-teardown.sh"],
        "GenChroot.debian-wheezy" : ["transfer/GenChroot.debian-wheezy-part-01.sh",
            "transfer/GenChroot.debian-wheezy-part-02.sh",
            "transfer/GenChroot.debian-wheezy-part-03.sh",
            "transfer/GenChroot.debian-wheezy-part-04.sh"],
        "chroot-imagelist-update" : ["transfer/chroot-imagelist-update.sh"],
        "chroot-scientific-6-repo" : ["transfer/chroot-scientific-6-repo.sh"],
        "publish-image-overlay" : ["transfer/publish-image-overlay-debian.sh"],
        "docbook-production" : [{   "script" : "transfer/chroot-debian-wheezy-buildup.sh"},
        
            {   "script" : "transfer/docbook-production.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["make", "git","openjdk-6-jre-lib","libservlet2.5-java", "openjdk-6-jre","openjdk-6-jre-headless", "fop", "xsltproc","docbook-xml","docbook-xsl" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {   "script" : "transfer/chroot-debian-wheezy-teardown.sh"},
            ],
        "vmcatcher-debian-wheezy-prod" : [{  "script" : "transfer/chroot-debian-wheezy-buildup.sh"},
            {   "script" : "transfer/vmcatcher-debian-wheezy-prod-part-03.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["git", "python","rpm","make", "python-setuptools","python-m2crypto", ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {   "script" : "transfer/chroot-debian-wheezy-teardown.sh"},
            ],
        "smimeX509validation-debian-wheezy-prod": [{  "script" : "transfer/chroot-debian-wheezy-buildup.sh"},
            {   "script" : "transfer/smimeX509validation-debian-wheezy-prod-part-04.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["git", "python","rpm","make", "python-setuptools","python-m2crypto", ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {   "script" : "transfer/chroot-debian-wheezy-teardown.sh"},
            ],
        "grid-virt-sort-debian-wheezy-prod-deb": [{  "script" : "transfer/chroot-debian-wheezy-buildup.sh"},
            {   "script" : "transfer/grid-virt-sort-debian-wheezy-prod-deb-build.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["debhelper", "git", "python","git-buildpackage","devscripts", "python-all",  "python-setuptools","python-m2crypto",] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {   "script" : "transfer/chroot-debian-wheezy-teardown.sh"},
            ],
        "grid-virt-sort-debian-wheezy-prod": [{  "script" : "transfer/chroot-debian-wheezy-buildup.sh"},
            {   "script" : "transfer/grid-virt-sort-debian-wheezy-prod-part-03.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["git", "python","rpm","make" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {   "script" : "transfer/chroot-debian-wheezy-teardown.sh"},
            ],
        "dirvacua-scientific-6-prod" : [{"script" : "transfer/chroot-scientific-6-buildup-prod.sh"},
            {   "script" : "transfer/dirvacua-scientific-6-prod.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Scientific" : ["org-desy-grid-virt-sort-release" ,"hepixvmitrust","git", "python","rpm-build","make","python-setuptools","m2crypto" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {"script" : "transfer/chroot-scientific-6-teardown.sh"}],
        
        "chroot-test-vmcatcher-scientific-6-prod" : [{"script" : "transfer/chroot-scientific-6-buildup-prod.sh"},
            {   "script" : "transfer/chroot-test-vmcatcher-scientific-6-prod.sh",
                "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Scientific" : ["org-desy-grid-virt-sort-release" ,"hepixvmitrust","git", "python","rpm","make","python-setuptools","m2crypto" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
            },
            {"script" : "transfer/chroot-scientific-6-teardown.sh"}],
        "vmcatcher-scientific-6-prod" : [{"script" : "transfer/chroot-scientific-6-buildup-prod.sh"},
                {"script" : "transfer/vmcatcher-scientific-6-prod.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Scientific" : ["python","rpm-build","make","git",
                    "python-setuptools","m2crypto" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },

                {"script" : "transfer/chroot-scientific-6-teardown.sh"}],
            
        "vmcatcher_eventHndlExpl_ON-scientific-6-prod" : [{"script" : "transfer/chroot-scientific-6-buildup-prod.sh"},
                {"script" : "transfer/vmcatcher_eventHndlExpl_ON-6-prod.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Scientific" : ["python","rpm-build","make","git",
                    "python-setuptools","m2crypto", "org-desy-grid-virt-sort-release" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },

                {"script" : "transfer/chroot-scientific-6-teardown.sh"}],    
        
        "dirvacua-debian-wheezy-prod" : [{"script" : "transfer/chroot-debian-wheezy-buildup.sh"},
                {   "script" : "transfer/dirvacua-debian-wheezy-prod-chrooted.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["python","rpm","make","git", "python-setuptools","python-m2crypto" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },
                {"script" : "transfer/chroot-debian-wheezy-teardown.sh"}],
        "chrootbuilder-debian-wheezy-prod": [{"script" : "transfer/chroot-debian-wheezy-buildup.sh"},
                {   "script" : "transfer/chrootbuilder-debian-wheezy-prod.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["python","rpm","make","git", "python-setuptools","python-m2crypto" ] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },
                {"script" : "transfer/chroot-debian-wheezy-teardown.sh"}],
        "hepixvmitrust-debian-wheezy-prod": [{"script" : "transfer/chroot-debian-wheezy-buildup.sh"},
                {   "script" : "transfer/hepixvmitrust-debian-wheezy-prod-chroot.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["git","python","rpm","make", "python-simplejson"  ,"python-m2crypto", "python-setuptools"] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },
                {"script" : "transfer/chroot-debian-wheezy-teardown.sh"}],
        "vmcaster-debian-wheezy-prod": [{"script" : "transfer/chroot-debian-wheezy-buildup.sh"},
                {   "script" : "transfer/vmcaster-debian-wheezy-prod-chroot.sh",
                    "shell" : { "type" : "chroot",
                    "command" : { "template" : "chroot %CHROOT%",
                        "envimeroment" : ["CHROOT"]
                        },
                    "dependancies" :{ "Debian" : ["git","python","rpm","make", "python-simplejson"  ,"python-m2crypto", "python-setuptools"] },
                    },
                "artifacts" : ["artifacts.tgz"],
                "flags" : ["chroot"],
                },
                {"script" : "transfer/chroot-debian-wheezy-teardown.sh"}],
        }
    if not jobname in mappings.keys():
        log.error("job is not mapped '%s' " % (jobname) )
        return 1
    log.info("job found '%s' " % (jobname) )
    enviroment = {}
    for jobpart in mappings[jobname]:
        jobDetails = {}
        if type(jobpart) == str:
            
            log.info("running jobpart '%s' " % (jobpart) )
            jobDetails["script"] = jobpart 
        if type(jobpart) == dict:
            jobDetails.update(jobpart)

        foo = jobPartRun()
        #requires = set(jobDetails["requires"])
        log.info("running jobDetails '%s' " % (jobDetails))
        if not "flags" in jobDetails.keys():
            jobDetails["flags"] = []
        resetMap = foo.executabingo(jobDetails,enviroment)
        if resetMap["env"] != 0:
            enviroment.update(resetMap["env"])
            log.debug("Job Enviroment='%s'" % (enviroment) )
        if resetMap["rc"] != 0:
            log.error("cmd '%s' returned '%s'." % (jobDetails,resetMap["rc"]))
            return resetMap["rc"]
        else:
            if "artifacts" in jobDetails.keys():
                rc = foo.getArtifacts(jobDetails,enviroment)
                if rc != True:
                    return rc
            else:
                log.info("No artifacts '%s' " % (jobDetails))
    return 0
        
        




def main():
    reload(sys)
    sys.setdefaultencoding('utf-8')
    log = logging.getLogger("main")
    p = optparse.OptionParser(version = "%prog " + "0.0.1")
    p.add_option('--log-config', action ='store',help='Logfile configuration file, (overrides command line).', metavar='LOGFILE')
    p.add_option('--logcfg', action ='store',help='Logfile configuration file.', metavar='LOGCFGFILE')
    p.add_option('-v', '--verbose', action ='count',help='Change global log level, increasing log output.', metavar='LOGFILE')
    p.add_option('-q', '--quiet', action ='count',help='Change global log level, decreasing log output.', metavar='LOGFILE')
    
    options, arguments = p.parse_args()
    if options.logcfg:
        if os.path.isfile(str(options.logfile)):
            logging.config.fileConfig(options.logfile)
        else:
            logging.basicConfig(level=logging.INFO)
            log = logging.getLogger("main")
            log.error("Logfile configuration file '%s' was not found." % (options.logfile))
            sys.exit(1)
    else:
        logging.basicConfig(level=logging.INFO)
    outputDict = None
    logFile = None
    
    if 'VMCHNDL_ON_LOG_CONF' in os.environ:
        logFile = os.environ['VMCHNDL_ON_LOG_CONF']
    if 'CHROOT' in os.environ:
        log.error("CHROOT in environ")
        sys.exit(1)
    
    # Set up log file
    LoggingLevel = logging.WARNING
    LoggingLevelCounter = 2
    if options.verbose:
        LoggingLevelCounter = LoggingLevelCounter - options.verbose
        if options.verbose == 1:
            LoggingLevel = logging.INFO
        if options.verbose == 2:
            LoggingLevel = logging.DEBUG
    if options.quiet:
        LoggingLevelCounter = LoggingLevelCounter + options.quiet
    if LoggingLevelCounter <= 0:
        LoggingLevel = logging.DEBUG
    if LoggingLevelCounter == 1:
        LoggingLevel = logging.INFO
    if LoggingLevelCounter == 2:
        LoggingLevel = logging.WARNING
    if LoggingLevelCounter == 3:
        LoggingLevel = logging.ERROR
    if LoggingLevelCounter == 4:
        LoggingLevel = logging.FATAL
    if LoggingLevelCounter >= 5:
        LoggingLevel = logging.CRITICAL
    
    if options.log_config:
        logFile = options.log_config
    if logFile != None:
        if os.path.isfile(str(options.log_config)):
            logging.config.fileConfig(options.log_config)
        else:
            logging.basicConfig(level=LoggingLevel)
            log = logging.getLogger("main")
            log.error("Logfile configuration file '%s' was not found." % (options.log_config))
            sys.exit(1)
    else:
        logging.basicConfig(level=LoggingLevel)
    log = logging.getLogger("main")

    jobname = None
    if 'JOB_NAME' in os.environ:
        jobname=os.environ['JOB_NAME']
    else:
        log.error("No JOB_NAME Enviroment variable set")
        sys.exit(2)
    log.info("JOB_NAME=%s" % jobname )
    
    rc = runJob(jobname)
    if rc != 0:
        log.error("runJob returned '%s'" % (rc) )
        sys.exit(2)
if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    main()
