source: 2014/24/build_games.py @ 4993

# -*- coding: latin-1 -*-
"""
Builds all the .csproj-projects in all subdirectories, copies
compiled games to directory games and optionally writes the
results of the build.
"""

from __future__ import with_statement
import sys
import os
from os.path import *
import shutil
from shutil import *
from glob import *
from subprocess import *
from datetime import *
import re

no_pong = False
should_write_results = True

output_dir = abspath("pelit")
build_result_dir = abspath("build")
lib_dir_x86 = abspath("lib")
personal_dirs = [d for d in os.listdir(".") if isdir(d) and d not in ("lib", basename(output_dir), ".svn")]
projects_that_did_not_build = []
users_that_did_not_build = []
msbuild = "msbuild"



def check_requirements():
    global msbuild
    if not exists("lib\\Jypeli.dll"):
        raise Exception("lib\\Jypeli.dll expected")
    return_code = call(msbuild + " /? 1> NUL 2> NUL", shell=True)
    if return_code != 0:
        msbuild = join(os.getenv("SystemRoot"), "Microsoft.NET\\Framework\\v4.0.30319\\MSBuild.exe")
        if not exists(msbuild):
            raise Exception("MSBuild not found in " + msbuild)


def create_output_directory():
    if not exists(output_dir):
        os.mkdir(output_dir)
    for d in personal_dirs:
        if not exists(join(output_dir, d)):
            os.mkdir(join(output_dir, d))

def create_build_result_directory():
    if not exists(build_result_dir):
        os.mkdir(build_result_dir)


def parse_last_changed_date(svn_info_output):
    match = re.search("Last Changed Date: (\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d) (\\d\\d):(\\d\\d)", svn_info_output)
    if not match:
        #raise Exception("Last Changed Date not found from svn info output!")
        return datetime(year=2000, month=1, day=1, hour=0, minute=0)
    year = int(match.group(1))
    month = int(match.group(2))
    day = int(match.group(3))
    hour = int(match.group(4))
    minute = int(match.group(5))
    return datetime(year=year, month=month, day=day, hour=hour, minute=minute)


def build_games():
    for d in personal_dirs:
        path = abspath(d)
        time = datetime(2000, 1, 1)
        if should_write_results and exists(join(path, ".svn")):
            call("svn update " + path, shell=True)
        outputs = Popen("svn info " + path, stdout=PIPE).communicate()
        time = parse_last_changed_date(outputs[0])
        try:
            build_games_in_personal_dir(path, time)
        except Exception, e:
            print
            print "NOT SUCCESSFUL FOR USER ", d, ": ", e
            users_that_did_not_build.append(d)


counter = 1


def get_weekday_name(n):
    if n == 0: return "Maanantai"
    if n == 1: return "Tiistai"
    if n == 2: return "Keskiviikko"
    if n == 3: return "Torstai"
    if n == 4: return "Perjantai"
    if n == 5: return "Lauantai"
    if n == 6: return "Sunnuntai"
    raise Exception("Invalid weekday number")


def write_result(author, name, success, last_changed_date):
    global counter
    with open(join(build_result_dir, str(counter)+".txt"), "w") as f:
        f.write(author+"\n")
        f.write(name+"\n")
        result = "success"
        if not success:
            result = "fail"
        f.write(result+"\n")
        formatted_time = get_weekday_name(last_changed_date.weekday()) + last_changed_date.strftime(" %H:%M")
        f.write(formatted_time+"\n")
    counter += 1


def build_games_in_personal_dir(personal_dir, last_changed_date):
    for root, dirs, files in os.walk(personal_dir):
        if '.svn' in dirs:
            dirs.remove('.svn')
        projects = glob(join(root, '*.csproj'))
        if projects:
            if len(projects) > 1:
                print "NOTE: There is more than one project file in", root

            try:
                project_name = splitext(basename(projects[0]))[0]
                author = basename(personal_dir)

                if re.search("consoleapplication", project_name, flags=re.IGNORECASE):
                    continue

                if no_pong and re.search("^pong", project_name, flags=re.IGNORECASE):
                    continue

                success = build(projects[0])

                if should_write_results:
                    write_result(author, project_name, success, last_changed_date)

                if success:
                    dst_dir = join(output_dir, author)
                    copy_game(project_name, root, dst_dir)
                    print author + ": " + project_name
                else:
                    projects_that_did_not_build.append(projects[0])
            except Exception, e:
                print
                print "PROJECT CAUSED EXCEPTION:", project_name, " :", e
                projects_that_did_not_build.append(projects[0])


def build(project_file_path):
    build_cmd = msbuild + ' /nologo /verbosity:quiet /p:XnaProfile=Reach /p:Configuration=Release /p:"ReferencePath=%s" /t:Build "%s"' % (lib_dir_x86, project_file_path)
    return call(build_cmd, shell=True) == 0


def copy_game(project_name, project_dir, dst_dir):
    bin = join(project_dir, "bin\\x86\\Release")
    if not exists(bin):
        print "NO BIN DIR FOUND IN", project_dir
    dst = join(dst_dir, project_name)
    if exists(dst):
        rmtree(dst)
    copytree(bin, dst, ignore=shutil.ignore_patterns('.svn', '*.pdb', 'jypeli.xml'))


def parse_arguments():
    for arg in sys.argv[1:]:
        if arg == "--write-results":
            global should_write_results
            should_write_results = True
        elif arg == "--no-pong":
            global no_pong
            no_pong = True
        else:
            raise Exception("Unknown argument: " + arg)


def main():
    try:
        parse_arguments()
        check_requirements()
        create_output_directory()
        if should_write_results: create_build_result_directory()
        build_games()
    except KeyboardInterrupt:
        print "BUILD CANCELLED"
    except Exception, e:
        print
        print "NOT SUCCESSFUL:", e
        return 1

    print 'Build failed for users (%d):' % len(users_that_did_not_build)
    for p in users_that_did_not_build:
        print p

    print
    print 'Build failed for projects (%d):' % len(projects_that_did_not_build)
    for p in projects_that_did_not_build:
        print p


if __name__ == '__main__':
    sys.exit(main())