axmol/tools/jenkins-scripts/master-scripts/cocos-console-test.py

#!/usr/bin/python
# create new project by adxe-console
# compile, deploy project and run
# perpose: for autotest adxe-console command.
# now support: mac- mac/ios/android
# will add: window-android,linux-android

import os
import subprocess
import sys
import json
import time
import socket
import threading
import smtplib
from email.mime.text import MIMEText
from os.path import join, getsize

# default console_param.
console_param = '[console run]'
# get param from commit.
if os.environ.has_key('payload'):
    payload_str = os.environ['payload']
    payload = json.loads(payload_str)
    if payload.has_key('console'):
        console_param = payload['console']
console_param = console_param[1:len(console_param)-1]
print 'console_param:',console_param

console_param_arr = console_param.split(' ')

# enum command type
class ENUM_PARAM:
    new = 0
    compile = 1
    deploy = 2
    run = 3

# partition different level
LEVEL_COCOS = {
    ENUM_PARAM.new : 1,
    ENUM_PARAM.compile : 2,
    ENUM_PARAM.deploy : 4,
    ENUM_PARAM.run : 8
}

# level's cocos command
COCOS_CMD = {
    ENUM_PARAM.new:'new',
    ENUM_PARAM.compile:'compile',
    ENUM_PARAM.deploy:'deploy',
    ENUM_PARAM.run:'run'
}

# set cocos_param for run different command
cocos_param = 0
for level in LEVEL_COCOS:
    if console_param_arr.count(COCOS_CMD[level]):
        cocos_param = cocos_param + LEVEL_COCOS[level]
if cocos_param < LEVEL_COCOS[ENUM_PARAM.new]:
    cocos_param = LEVEL_COCOS[ENUM_PARAM.new]
print 'cocos_param:', cocos_param

# project types
project_types = ['cpp', 'lua']
# project suffix
PROJ_SUFFIX = 'Proj'
# different phone platform
phonePlats = ['mac','ios','android']

# need use console's position, perhaps should be set an env-param
cocos_console_dir = 'tools/console/bin/'

# now adxe-console suport different run on Platforms, e.g: only run android on win
runSupport = {
    'darwin' : {'mac':1,'ios':1,'android':1},
    'win' : {'mac':0,'ios':0,'android':1},
    'linux' : {'mac':0,'ios':0,'android':1}
}

# get current running system
curPlat = sys.platform
if curPlat.find('linux') >= 0:
    curPlat = 'linux'
elif curPlat.find('darwin') >= 0:
    curPlat = 'darwin'
else:
    curPlat = 'win'
print 'current platform is:', curPlat

# delete project.(will use different system command to delete.just mac now.)
def clean_project():
    print 'delete older project.'
    for proj in project_types:
        cmd = 'rm -rf '+proj+PROJ_SUFFIX
        os.system(cmd)

# file path.(for add console listen command.)
FILE_PATH = '/Classes/AppDelegate.cpp'
FILE_DIR = {
    'cpp':'',
    'lua':'/frameworks/runtime-src'
}
PARSE_WORD = 'director->setDisplayStats(true);'
CONSOLE_COMMAND = 'director->getConsole()->listenOnTCP(5678);'

# add console listenOnTCP to AppDelegate.cpp.
def addConsoleListenOnTCP(name):
    filePath = name+PROJ_SUFFIX+FILE_DIR[name]+FILE_PATH
    print 'filePath:',filePath
    strCont = ''
    if os.path.isfile(filePath):
        file_object = open(filePath, 'r')
        strLine = file_object.readline() 
        while strLine:
            strCont = strCont + strLine
            if strLine.find(PARSE_WORD) > -1:
                print 'add console listenOnTCP command.'
                strCont = strCont+'\n\t' + CONSOLE_COMMAND + '\n'
            strLine = file_object.readline() 
        
        file_object.close()
        file_object = open(filePath, 'w')
        file_object.write(strCont)
        file_object.close()
        time.sleep(2)
    else:
        print 'file is not exist.'

# console result, for record result
console_result = 'the result of cocos-console-test is:\n\r'

# get current android devices count.
def getAndroidDevices():
    cmd = 'adb devices'
    info_devices = os.popen(cmd).read()
    arrDevices = info_devices.split('\n')
    del arrDevices[0]
    count = 0
    for device in arrDevices:
        # e.g: emulator-5554    device, contains 'device', so, min length is len('device')
        if len(device) > len('device') and (device.find('device') >= 0):
            count += 1
    return count

# close running app or exe by using console command.
IP_PHONE = {
    'mac':'localhost',
    'ios':'localhost'
}
PORT = 5678

def close_proj(proj, phone):
    print 'close running project'
    # connect socket
    strClose = 'close ' + proj + ' on ' + phone
    if IP_PHONE.has_key(phone):
        soc = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
        print proj, phone, IP_PHONE[phone]
        try:
            soc.connect((IP_PHONE[phone], PORT))
            cmd = 'director end\r\n'
            print 'cmd close:', cmd
            soc.send(cmd)
            time.sleep(2) 
            strClose = strClose + ' success.'
        except Exception, e:
            print 'socket is not connect.'
            strClose = strClose + ' failed.' + ' socket is not connect.'
    else:
        strClose = strClose + ' failed.' + ' no ' +phone+ ' type.'
    time.sleep(2)
    return strClose

# appendToResult
def appendToResult(content):
    global console_result
    console_result = console_result + content

info_of_close_app = {}
cur_test_name = ''
class myThread(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)
    def run(self):
        run_name = self.getName()
        print 'run_name:', run_name
        if run_name == 'close':
            while True:
                soc = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
                try:
                    soc.connect(('localhost', PORT))
                    cmd_close = 'director end\r\n'
                    print 'cmd close:', cmd_close
                    soc.send(cmd_close)
                    time.sleep(2)
                    global cur_test_name
                    print 'cur_test_name:', cur_test_name
                    info_of_close_app[cur_test_name] = True
                    break
                except Exception, e:
                    time.sleep(5)

# if any error 
ANY_ERROR_IN_RUN = 0
# excute cocos command
def cocos_project(level):
    global ANY_ERROR_IN_RUN
    print 'will excute cocos_command: ', COCOS_CMD[level], level
    appendToResult('will excute ' + COCOS_CMD[level] + ' command:'+"\n\r\t")
    for proj in project_types:
        print 'proj: ', proj
        if level == ENUM_PARAM.new:
            cmd = './'+cocos_console_dir+'cocos new -l '+proj+' '+proj+PROJ_SUFFIX
            print proj,'cmd:',cmd
            info_create = os.system(cmd)    #call cmd on win is diff
            if info_create == 0:
                time.sleep(12)
                addConsoleListenOnTCP(proj)
            print 'create project',proj,' is:', not info_create
            ANY_ERROR_IN_RUN = ANY_ERROR_IN_RUN + info_create
            appendToResult('    '+cmd +': ' + str(not info_create) + ".\n\r\t")
        else:
            for phone in phonePlats:
                print 'platform is: ', phone
                cmd = './'+cocos_console_dir+'cocos '+COCOS_CMD[level]+' -s '+proj+PROJ_SUFFIX+' -p '+phone
                print 'cmd:',cmd
                info_cmd = ''
                if level == ENUM_PARAM.compile:
                    if runSupport[curPlat][phone]:
                        info_cmd = os.system(cmd)
                        print 'info '+COCOS_CMD[level]+':', not info_cmd
                        appendToResult('    '+cmd +': ' + str(not info_cmd) + ".\n\r\t")
                else:
                    if runSupport[curPlat][phone]:
                        print 'in desploy or run:', phone, getAndroidDevices()
                        if phone == 'android' and getAndroidDevices() == 0:
                            strInfo = 'no android device, please checkout the device is running ok.'
                            print strInfo
                        else:
                            if level == ENUM_PARAM.run:
                                global cur_test_name
                                cur_test_name = proj+','+phone
                                thread_close = myThread('close')
                                thread_close.start()
                            info_cmd = os.system(cmd)
                            time.sleep(5)
                            appendToResult('    '+cmd +': ' + str(not info_cmd) + ".\n\r\t")

# build and run according to params of provided.(lv_ignore: e.g:ignore new)
def build_run(lv_ignore):
    print 'will build and run, in function build_run'
    for level in LEVEL_COCOS:
        print 'level:', level, cocos_param, LEVEL_COCOS[level]
        if cocos_param >= LEVEL_COCOS[level] and level > lv_ignore:
            if level == ENUM_PARAM.new:
                clean_project()
            cocos_project(level)

# android simulator name.
ANDROID_SIMULATOR_NAME = 'console-test'
# start android simulator if no android devices connected.
def start_android_simulator():
    print 'in function start_android_simulator.'
    if getAndroidDevices() > 0:
        print 'already connected android device.'
        return
    if cocos_param >= LEVEL_COCOS[ENUM_PARAM.deploy]:
        cmd_start = [ 'emulator -avd '+ANDROID_SIMULATOR_NAME ]
        # print 'cmd_start:', cmd_start
        # info_start = subprocess.Popen(cmd_start, stdin=subprocess.PIPE, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        # print 'start an android simulator:', not info_start

# send email
EMAIL_KEYS={
    0:'EMAIL_HOST',
    1:'EMAIL_USER',
    2:'EMAIL_PWD',
    3:'EMAIL_POSTFIX',
    4:'EMAIL_LIST',
    5:'NEED_SEND_EMAIL'
}

OBJ_EMAIL_INFO = {}
print 'will get env info.'
for key in EMAIL_KEYS:
    if os.environ.has_key(EMAIL_KEYS[key]):
        OBJ_EMAIL_INFO[EMAIL_KEYS[key]] = os.environ[EMAIL_KEYS[key]]
        if key == 4:
            # string to list by ' ', for separate users.
            OBJ_EMAIL_INFO[EMAIL_KEYS[4]] = OBJ_EMAIL_INFO[EMAIL_KEYS[4]].split(' ')

print 'will send email.', OBJ_EMAIL_INFO
def send_mail(to_list,sub,title,content):
    mail_user = OBJ_EMAIL_INFO[ EMAIL_KEYS[1] ]
    mail_postfix = OBJ_EMAIL_INFO[ EMAIL_KEYS[3] ]
    mail_host = OBJ_EMAIL_INFO[ EMAIL_KEYS[0] ]
    mail_pass = OBJ_EMAIL_INFO[ EMAIL_KEYS[2] ]
    me = mail_user+"<"+mail_user+"@"+mail_postfix+">"
    msg = MIMEText(content,_subtype='plain',_charset='gb2312')
    msg['Subject'] = sub
    msg['From'] = me
    msg['To'] = " ".join(to_list)
    print 'to users:', msg['To']
    msg['Content'] = 'test'
    try:
        s = smtplib.SMTP()
        s.connect(mail_host)
        s.login(mail_user,mail_pass)
        s.sendmail(me, to_list, str(msg))
        print 'info:', me, to_list, str(msg)
        s.close()
        appendToResult( 'send email true:' + str(msg) )
        return True
    except Exception, e:
        appendToResult( 'send email false:' + str(e) )
        print str(e)
        return False

def sendEmail(msg):
    send_mail(OBJ_EMAIL_INFO[EMAIL_KEYS[4]], "cocos-console-test result", 'for error.', msg)

# get package size 
def getdirsize(dir):  
    size = 0L  
    for root, dirs, files in os.walk(dir):  
        size += sum([getsize(join(root, name)) for name in files])  
    return size
APP_FILE_DIR = {
    'cpp':'bin/debug/',
    'lua':'runtime/'
}
APP_FILE_SUFFIX = {
    'mac':'.app',
    'ios':'.app',
    'android':'-debug-unaligned.apk'
}
if os.environ.has_key('APP_FILE_SUFFIX'):
    str_app_suffix = os.environ['APP_FILE_SUFFIX']
    APP_FILE_SUFFIX = eval(str_app_suffix)

def getPackageSize():
    for proj in project_types:
        for phone in phonePlats:
            # if runSupport[curPlat][phone]:
            package_path = './'+proj+PROJ_SUFFIX+'/'+APP_FILE_DIR[proj]+phone+'/'+proj+PROJ_SUFFIX+APP_FILE_SUFFIX[phone]
            print 'package_path', package_path
            package_size = 0
            if os.path.isfile(package_path):
                package_size = os.path.getsize(package_path);
            else:
                package_size = getdirsize(package_path);
            strSize = 'size of '+proj+PROJ_SUFFIX+' '+phone+' is:'+str(package_size/(1024))+'KB'+'\n\t'
            print 'strSize:', strSize
            appendToResult(strSize)

def main():
    print 'in main:'
    # start_android_simulator()
    print 'will build_run:'
    build_run(-1)
    print 'ANY_ERROR_IN_RUN:', ANY_ERROR_IN_RUN
    print 'end build run. and get package size.'
    getPackageSize()
    print 'will send email:'
    print 'console_result:', console_result
    if OBJ_EMAIL_INFO[ EMAIL_KEYS[5] ] or ANY_ERROR_IN_RUN:
        sendEmail(console_result)

# -------------- main --------------
if __name__ == '__main__':
    sys_ret = 0
    try:
        sys_ret = main()
    except:
        traceback.print_exc()
        sys_ret = 1
    finally:
        sys.exit(sys_ret)