# Copyright (c) 2005-2009 Nokia Corporation

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

import sys

import base64

if sys.version_info < (2, 4):

    print "Python 2.4 or later required."

    sys.exit(2)

import os

from subprocess import *

import thread

from threading import Thread

import re

import imp

import compileall

import traceback

from zipfile import ZipFile

import time

import glob

import itertools

import string

from optparse import OptionParser

topdir = os.getcwd()

testdata_dir = '.\\build\\test'

testdir = os.path.abspath(os.path.join(topdir,

                                       '..\\test\\automatic\\standard'))

sys.path.append(os.path.join(topdir, 'tools'))

sys.path.append(os.path.join(topdir, 'newcore\\Symbian\\src'))

import fileutil

import template_engine

import module_config_parser

from shellutil import *

internal_proj = False

# Specify the magic number of the Python interpreter used in PyS60.

pys60_magic_number = '\xb3\xf2\r\n'

projects = [{'name': 'python25',

             'path': 'newcore\\symbian\\group',

             'internal': False},

            {'name': 'testapp',

             'path': 'ext\\test\\testapp\\group',

             'internal': False},

            {'name': 'run_testapp',

             'path': 'ext\\test\\run_testapp\\group',

             'internal': True},

            {'name': 'run-interpretertimer',

             'path': 'ext\\test\\run-interpretertimer\\group',

             'internal': True},

            {'name': 'interpreter-startup',

             'path': 'ext\\test\\interpreter-startup\\group',

             'internal': True}]

buildconfig_defaults={'PYS60_VERSION_MAJOR': 2,

                      'PYS60_VERSION_MINOR': 0,

                      'PYS60_VERSION_MICRO': 0,

                      # The default tag for a build is based on the

                      # time the configuration script was run. To make

                      # a build that claims to be a "release" build

                      # you need to specify a PYS60_VERSION_TAG

                      # explicitly.

                      'PYS60_VERSION_TAG': time.strftime(

                                           "development_build_%Y%m%d_%H%M"),

                      'PYS60_RELEASE_DATE': time.strftime("%d %b %Y"),

                      'PY_CORE_VERSION': '2.5.4',

                      'PY_ON_BUILD_SERVER': '2.5.1',

                      'PYS60_VERSION_SERIAL': 0,

                      'EMU_BUILD': 'udeb',

                      'DEVICE_PLATFORM': 'armv5',

                      'DEVICE_BUILD': 'urel',

                      'SRC_DIR': topdir,

                      'TEST_DIR': testdir,

                      'PROJECTS': projects,

                      'INTERNAL_PROJ': internal_proj,

                      'COMPILER_FLAGS': '',

                      'TEST_FLAG': 'OFF',

                      'EXTRA_SYSTEMINCLUDE_DIRS': [],

                      'WITH_MESSAGING_MODULE': 1,

                      'WITH_LOCATION_MODULE': 1,

                      'WITH_SENSOR_MODULE': 1,

                      'PREFIX': 'kf_',

                      'INCLUDE_ARMV5_PYDS': False,

                      'CTC_COVERAGE': False,

                      # UIDs 10201510 to 10201519 inclusive, allocated for

                      # PyS60 1.4.x

                      'PYS60_UID_CORE': '0x20022EE8',

                      'PYS60_UID_S60': '0x10201510',

                      'PYS60_UID_LAUNCHER': '0x20022EF0',

                      'PYS60_UID_TESTAPP': '0xF0201517',

                      'PYS60_UID_RUNTESTAPP': '0xF0201518',

                      'PYS60_UID_PYTHONUI': '0xF020151B',

                      'PYS60_UID_PYREPL': '0x10201519',

                      'OMAP2420': 0}

buildconfig_sdks = {

    '30armv5': {'S60_VERSION': 30,

           'DEVICE_PLATFORM': 'armv5',

           'EMU_PLATFORM': 'winscw',

           'SDK_NAME': 'S60 3rd Ed. w/ RVCT compiler',

           'SDK_MARKETING_VERSION_SHORT': '3rdEd',

           'PYS60_UID_SCRIPTSHELL': '0x20022EED',

           'S60_REQUIRED_PLATFORM_UID': '0x101F7961'},

    '30gcce': {'S60_VERSION': 30,

           'DEVICE_PLATFORM': 'gcce',

           'EMU_PLATFORM': 'winscw',

           'PYS60_UID_SCRIPTSHELL': '0x20022EED',

           'SDK_NAME': 'S60 3rd Ed. w/ GCCE compiler',

           'SDK_MARKETING_VERSION_SHORT': '3rdEd',

           'S60_REQUIRED_PLATFORM_UID': '0x101F7961'},

    '32': {'S60_VERSION': 32,

           'DEVICE_PLATFORM': 'armv5',

           'EMU_PLATFORM': 'winscw',

           'PYS60_UID_SCRIPTSHELL': '0x20022EEC',

           'SDK_NAME': 'S60 3rd EdFP2  w/ RVCT compiler',

           'SDK_MARKETING_VERSION_SHORT': '3rdEdFP2',

           'S60_REQUIRED_PLATFORM_UID': '0x102752AE'},

    '32gcce': {'S60_VERSION': 32,

           'DEVICE_PLATFORM': 'gcce',

           'EMU_PLATFORM': 'winscw',

           'PYS60_UID_SCRIPTSHELL': '0x20022EEC',

           'SDK_NAME': 'S60 3rd EdFP2  w/ GCCE compiler',

           'SDK_MARKETING_VERSION_SHORT': '3rdEdFP2',

           'S60_REQUIRED_PLATFORM_UID': '0x102752AE'},

    '50armv5': {'S60_VERSION': 50,

           'DEVICE_PLATFORM': 'armv5',

           'EMU_PLATFORM': 'winscw',

           'PYS60_UID_SCRIPTSHELL': '0x20022EEC',

           'SDK_NAME': 'S60 5th Ed  w/ RVCT compiler',

           'SDK_MARKETING_VERSION_SHORT': '5thEd',

           'S60_REQUIRED_PLATFORM_UID': '0x1028315F'}}

# 0 if missing files in SDK zip packaging are not allowed

allow_missing = 0

BUILDCONFIG_FILE = os.path.join(topdir, 'build.cfg')

def buildconfig_exists():

    return os.path.exists(BUILDCONFIG_FILE)

def buildconfig_load():

    global BUILDCONFIG

    if buildconfig_exists():

        BUILDCONFIG = eval(open(BUILDCONFIG_FILE, 'rt').read())

    else:

        raise BuildFailedException("Source not configured")

def buildconfig_save():

    open(BUILDCONFIG_FILE, 'wt').write(repr(BUILDCONFIG))

def buildconfig_clean():

    if os.path.exists(BUILDCONFIG_FILE):

        delete_file(BUILDCONFIG_FILE)

def get_project_details(params):

    buildconfig_load()

    requested_detail = []

    for project in projects:

        if not project['internal'] or BUILDCONFIG['INTERNAL_PROJ']:

            requested_detail.append(project[params])

    return requested_detail

def scanlog(log):

    analysis = run_shell_command('perl \\epoc32\\tools\\scanlog.pl', log)

    m = re.search(r'^Total\s+[0-9:]+\s+([0-9]+)\s+([0-9]+)',

                  analysis['stdout'], re.M)

    if m:

        return {'analysis': analysis,

                'errors': int(m.group(1)),

                'warnings': int(m.group(2))}

    else:

        raise Exception('scanlog.pl failed')

def run_command_and_check_log(cmd, verbose=1, ignore_errors=0):

    print 'Running "%s"' % cmd

    try:

        out = run_shell_command(cmd, mixed_stderr=1, verbose=verbose)

        n_errors = 0

        scanlog_result = scanlog(out['stdout'])

        n_errors = scanlog_result['errors']

    except:

        if ignore_errors:

            print 'Ignoring exception "%s" raised by command "%s"' \

            %(traceback.format_exception_only(sys.exc_info()[0], \

            sys.exc_info()[1]), cmd)

            return

        raise

    if n_errors > 0:

        if ignore_errors:

            print 'Ignoring errors of command "%s"' % cmd

        else:

            raise BuildFailedException('Command "%s" failed:\n%s' \

                                        % (cmd, out['stdout']))

def enter(dir):

    absdir = os.path.join(topdir, dir)

    print 'Entering "%s"' % absdir

    os.chdir(absdir)

def run_in(relative_dir, cmd, verbose=1, ignore_errors=0):

    curr_dir = os.getcwd()

    enter(relative_dir)

    run_command_and_check_log(cmd, verbose=verbose,

                              ignore_errors=ignore_errors)

    os.chdir(curr_dir)

def parse_assignments(params):

    d = {}

    for item in params:

        (name, value) = item.split('=')

        try:

            value = int(value)

        except ValueError:

            pass # not an integer

        d[name] = value

    return d

def cmd_configure(params):

    global BUILDCONFIG

    BUILDCONFIG = {}

    BUILDCONFIG.update(buildconfig_defaults)

    parser = OptionParser()

    parser.add_option("-p", "--profile_log", dest="profile",

            action="store_true", default=False,

            help="Profile log generator for python [default: %default]")

    parser.add_option("-v", "--version", dest="version", default='2.0.0',

            help="Python release version [default: %default]")

    parser.add_option("--compiler-flags", dest="compiler_flags",

            default='',

            help="Compiler flags to be used while building the python" +

                 " interpreter core [default: %default]")

    parser.add_option("--internal-projects", dest="internal_proj",

            action="store_true", default=False,

            help="Builds internal projects like 'interpreter-startup, " +

                 "run_testapp etc...  [default: %default]")

    parser.add_option("--version-tag", dest="version_tag", default='final',

            help="Specify release tag [default: %default]")

    parser.add_option("-s", "--sdk", dest="sdk", default='50armv5',

            help="Specify the version of sdk to use, choose any version " +

                 "from %s"%",".join(buildconfig_sdks.keys()) +

                 "[default: %default]")

    parser.add_option("-c", "--caps", dest="dll_caps",

            default='LocalServices NetworkServices ReadUserData ' +

                    'WriteUserData UserEnvironment Location',

            help="Specify DLL capability within quotes [default: %default]")

    parser.add_option("--debug-device", dest="debug_device",

            action='store_true',

            help="Build device builds in debug mode.")

    parser.add_option("--include-internal-src", action='store_true',

            dest="include_internal_src", default=False,

            help="Include the source under ..\internal-src for build." +

                 " [default: %default]")

    parser.add_option("--exe-caps", dest="exe_caps",

            help="Specify EXEs capability within quotes. " +

                 "If nothing is specified this will be same as DLL " +

                 "capabilities")

    parser.add_option("--compression-type",

            default='', dest="compression_type",

            help="Modify the compression type of all the " +

                 "E32Image files generated, using 'elftran " +

                 "-compressionmethod'. Refer elftran help for valid " +

                 "compression types. If the type is given as '', " +

                 "elftran is not invoked for modifying the compression type." +

                 " [default: '']")

    parser.add_option("-k", "--key", dest="key",

            help="Specify key name," +

                 " [default:  NONE] - packages are left unsigned")

    parser.add_option("--keydir", dest="keydir", default='..\\keys',

            help="Specify key path [default: %default])")

    parser.add_option("--do-not-compile-pyfiles",

            dest="do_not_compile_pyfiles", action="store_true", default=False,

            help="Do not compile the .py files under src. You can disable the "

                 "compilation if the Python version on the host system is not "

                 "bytecode compatible with the Python used in PyS60 "

                 "[default: %default]")

    parser.add_option("--build-profile",

            dest="build_profile", default='integration',

            help="Use this option to set the build_config variable, "

                 "BUILD_PROFILE to 'integration' or 'release'. BUILD_PROFILE "

                 "can then be used in the template processing. "

                 "[default: %default]")

    (options, args) = parser.parse_args()

    if not options.do_not_compile_pyfiles and \

                                      pys60_magic_number != imp.get_magic():

        raise SystemError("Not compiling the .py files: " + \

              "Python version(%s) " % sys.version.split()[0] + \

              "not bytecode compatible with the Python version " + \

              "used in PyS60(%s)." % BUILDCONFIG['PY_ON_BUILD_SERVER'])

    if options.sdk not in buildconfig_sdks:

        print 'Unsupported SDK configuration "%s"' % options.sdk

        sys.exit(2)

    # Find out if coverage called configure. There are chances that the cfg

    # file is missing or CTC_COVERAGE key is not present. We just ignore it.

    try:

        BUILDCONFIG_temp = eval(open(BUILDCONFIG_FILE, 'rt').read())

        if BUILDCONFIG_temp['CTC_COVERAGE']:

            BUILDCONFIG['CTC_COVERAGE'] = True

    except:

        pass

    BUILDCONFIG['PYS60_VERSION_NUM'] = options.version

    BUILDCONFIG['PYS60_VERSION'] = '%s %s' %(options.version,

                                             options.version_tag)

    [major, minor, micro] = options.version.split('.')

    BUILDCONFIG['PYS60_VERSION_MAJOR'] = major

    BUILDCONFIG['PYS60_VERSION_MINOR'] = minor

    BUILDCONFIG['PYS60_VERSION_MICRO'] = micro

    BUILDCONFIG['BUILD_PROFILE'] = options.build_profile

    if options.compiler_flags:

        BUILDCONFIG['COMPILER_FLAGS'] = "OPTION " \

        + options.compiler_flags

        log_file = topdir + "\\build\\regrtest_emulator_x86.log"

        if os.path.exists(log_file):

            open(log_file, "a+").write("\n" +

                "Build Info -- Name : <Compiler Flags>, Value : <" +

                options.compiler_flags + ">")

            # Running it again to get the compiler tags into the XML. In the

            # future when new build info metrics will be added, this can be

            # run at the end after appending all the values to emu log.

            run_cmd('python tools\\regrtest_log_to_cruisecontrol.py ' +

                    ' regrtest_emulator_x86.log')

    BUILDCONFIG['PYS60_VERSION_TAG'] = options.version_tag

    BUILDCONFIG['PROFILE_LOG'] = options.profile

    buildconfig_save()

    if options.key:

        BUILDCONFIG['SIGN_KEY'] = options.keydir + '\\' + \

        '%s' % options.key + '.key'

        BUILDCONFIG['SIGN_CERT'] = options.keydir + '\\' + \

        '%s' % options.key + '.crt'

        BUILDCONFIG['SIGN_PASS'] = ''

    BUILDCONFIG['DLL_CAPABILITIES'] = options.dll_caps

    if not options.exe_caps:

        BUILDCONFIG['EXE_CAPABILITIES'] = options.dll_caps

    else:

        BUILDCONFIG['EXE_CAPABILITIES'] = options.exe_caps

    BUILDCONFIG['COMPRESSION_TYPE'] = options.compression_type

    BUILDCONFIG.update(buildconfig_sdks[options.sdk])

    if options.debug_device:

        print "Configuring the device build as debug(UDEB)"

        BUILDCONFIG['DEVICE_BUILD'] = 'udeb'

    if options.internal_proj:

        global INTERNAL_PROJ

        BUILDCONFIG['INTERNAL_PROJ'] = True

    BUILDCONFIG['INCLUDE_INTERNAL_SRC'] = options.include_internal_src

    BUILDCONFIG['MOD_REPO'] = False

    print "Configuring for %s" % options.sdk

    buildconfig_save()

    # Check if a directory for build dependencies was given

    if 'BUILD_DEPS' in BUILDCONFIG:

        # Form the build dependencies include directory path. The

        # drive letter and colon are stripped from the path since the

        # Symbian build system doesn't understand drive letters in

        # paths.

        builddep_includes = os.path.abspath(os.path.join(

                            BUILDCONFIG['BUILD_DEPS'], BUILDCONFIG['SDK_TAG'],

                            'include'))[2:]

        if os.path.exists(builddep_includes):

            print "Adding extra include directory %s" % builddep_includes

            BUILDCONFIG['EXTRA_SYSTEMINCLUDE_DIRS'].append(builddep_includes)

    buildconfig_save()

    print "Build configuration:"

    for name, value in sorted(BUILDCONFIG.items()):

        print "  %s=%s" % (name, repr(value))

    BUILDCONFIG['ConfigureError'] = ConfigureError

    build_dirs = ['']

    if options.include_internal_src:

        build_dirs.append('..\\internal-src')

        build_dirs.append('..\\extraprojs')

    if not options.do_not_compile_pyfiles:

        compileall.compile_dir('newcore\\Lib', rx=re.compile('/[.]svn'))

    prev_dir = os.getcwd()

    os.chdir('newcore\\Symbian\\src')

    execfile('module_config_parser.py', BUILDCONFIG)

    os.chdir(prev_dir)

    # Go through all directories that have template files that need processing.

    for dir_ in build_dirs:

        for f in fileutil.all_files(dir_, '*.in'):

            # Omit newcore from template processing for now.

            if (f.startswith('newcore\\') or f.startswith('build\\')) and \

            not f.startswith('newcore\\Symbian\\') and \

            not f.startswith('newcore\\Doc\\s60'):

                print "Ignoring", f

                continue

            print "Processing template", f

            template_engine.process_file(f, BUILDCONFIG)

    for x in get_project_details('path'):

        run_in(x, 'bldmake clean')

        run_in(x, 'bldmake bldfiles')

def cmd_generate_ensymble(params):

    print "Building for ensymble started"

    buildconfig_load()

    mod_depcfg_dir = 'newcore\\Symbian\\src\\'

    ensymble_dir = 'tools\\py2sis\\ensymble\\'

    stub_dirs = ['tools\\py2sis\\python_console\\group',

                 'ext\\amaretto\\python_ui\\group']

    # It is a prerequisite for ensymble to have python built for armv5

    if not os.path.exists("\\epoc32\\release\\armv5\\urel\\python25.dll"):

        raise RuntimeError('Python not built for ARMV5')

    for stub_dir in stub_dirs:

        run_in(stub_dir, 'abld -keepgoing reallyclean armv5', ignore_errors=1)

        run_in(stub_dir, 'bldmake clean')

        run_in(stub_dir, 'bldmake bldfiles')

        run_in(stub_dir, 'abld build \

                     %(EMU_PLATFORM)s %(EMU_BUILD)s ' % BUILDCONFIG)

        run_in(stub_dir, 'abld build \

                     %(DEVICE_PLATFORM)s %(DEVICE_BUILD)s ' % BUILDCONFIG)

    run_in(ensymble_dir, 'python genensymble.py')

    os.chdir('newcore\\Symbian\\src')

    BUILDCONFIG['MOD_REPO'] = True

    execfile('module_config_parser.py', BUILDCONFIG)

    os.chdir(topdir)

    py_files = []

    os.chdir(mod_depcfg_dir)

    if os.path.exists('module_dependency.cfg'):

        shutil.move('module_dependency.cfg',

            os.path.join(topdir, ensymble_dir,

            'module-repo', 'standard-modules'))

    os.chdir(topdir)

    BUILDCONFIG['MOD_REPO'] = False

def cmd_build(params):

    global build_emulator

    global build_devices

    parser = OptionParser()

    parser.add_option("--emu", action="store_true",

            dest="build_emulator", default=False,

            help="Build for Emulator")

    parser.add_option("--device", action="store_true",

            dest="build_devices", default=False,

            help="Build for device")

    (options, args) = parser.parse_args()

    build_emulator = options.build_emulator

    build_devices = options.build_devices

    if build_emulator:

        # This check is done because when option(--emu or --device), is given

        # with the subsystem(ext\amaretto\<module>\group), the subsytem is

        # passed as the params

        if params.__len__() >= 2:

            build_emu(params[1:2])

        else:

            params = []

            build_emu(params)

    elif build_devices:

        if params.__len__() >= 2:

            build_device(params[1:2])

        else:

            params = []

            build_device(params)

    # if build option is specified without arguments then build for emulator

    # and device

    else:

        build_emu(params)

        build_device(params)

def build_module(params, build):

    if build == "emu":

        platform_type = '%(EMU_PLATFORM)s' % BUILDCONFIG

        build_type = '%(EMU_BUILD)s' % BUILDCONFIG

    elif build == "device":

        platform_type = '%(DEVICE_PLATFORM)s' % BUILDCONFIG

        build_type = '%(DEVICE_BUILD)s' % BUILDCONFIG

    if os.path.exists(params[0]):

        module_dir = params[0]

    else:

        module_dir = 'ext\\%s\\group' % params[0]

    run_in(module_dir, 'abld -keepgoing reallyclean %s' % platform_type,

           ignore_errors=1)

    run_in(module_dir, 'bldmake clean')

    run_in(module_dir, 'bldmake bldfiles')

    run_in(module_dir, 'abld build %s %s' %(platform_type, build_type))

def build_emu(params):

    buildconfig_load()

    if params:

        build_module(params, "emu")

    else:

        deltree_if_exists('\\epoc32\\winscw\\c\\data\\python\\test')

        os.makedirs('\\epoc32\\winscw\\c\\data\\python\\test')

        for x in get_project_details('path'):

            run_in(x, 'abld build %(EMU_PLATFORM)s %(EMU_BUILD)s '

                   % BUILDCONFIG)

def build_device(params):

    buildconfig_load()

    if params:

        build_module(params, "device")