645 lines
24 KiB
Python
Executable file
645 lines
24 KiB
Python
Executable file
#!/usr/bin/env python
|
|
# Version: MPL 1.1 / GPLv3+ / LGPLv3+
|
|
|
|
# The contents of this file are subject to the Mozilla Public License Version
|
|
# 1.1 (the "License"); you may not use this file except in compliance with
|
|
# the License or as specified alternatively below. You may obtain a copy of
|
|
# the License at http://www.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS" basis,
|
|
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
# for the specific language governing rights and limitations under the
|
|
# License.
|
|
#
|
|
# The Initial Developer of the Original Code is
|
|
# Yifan Jiang, SUSE <yfjiang@suse.com>
|
|
# Portions created by the Initial Developer are Copyright (C) 2011 the
|
|
# Initial Developer. All Rights Reserved.
|
|
#
|
|
# Major Contributor(s):
|
|
#
|
|
# Portions created by the Ted are Copyright (C) 2010 Ted. All Rights Reserved.
|
|
#
|
|
# For minor contributions see the git repository.
|
|
#
|
|
# Alternatively, the contents of this file may be used under the terms of
|
|
# either the GNU General Public License Version 3 or later (the "GPLv3+"), or
|
|
# the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"),
|
|
# in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable
|
|
# instead of those above.
|
|
##
|
|
# The tool is designed to enable test machine fully automatically run smoketest
|
|
# with both daily and pre release build located in dev-build.libreoffice.org.
|
|
#
|
|
# The tool is named as losmoketest for its purpose, meanwhile it help you to
|
|
# check, download and install the latest build. By the fact the installation is
|
|
# designed not to be different from manually doing these repeated work, the
|
|
# installed libreoffice build can also be good for manual test.
|
|
|
|
import sys, os, platform
|
|
import datetime, time
|
|
import subprocess, shutil
|
|
import glob, re
|
|
import urllib, urllib2
|
|
import logging, getopt
|
|
try:
|
|
import ConfigParser as configparser # Python 3.0 change
|
|
except ImportError:
|
|
import configparser
|
|
|
|
# FIXME: make this configurable via options or autodetect it
|
|
build_version = "3.5"
|
|
tag_version = "3-5"
|
|
# devel build
|
|
install_dirname="lo-dev"
|
|
branding_pack="libo-dev"
|
|
basis_pack="libobasis-dev"
|
|
ure_pack="lodev"
|
|
# stable build
|
|
#install_dirname="libreoffice" + build_version
|
|
#branding_pack="libreoffice"
|
|
#basis_pack="libobasis"
|
|
#ure_pack="libreoffice"
|
|
|
|
build_check_interval = 5 #seconds
|
|
|
|
# Distro list
|
|
RPM_DISTRO_LIST = ['SuSE', 'fedora', 'redhat', 'centos', 'mandrake', 'mandriva', 'yellowdog', 'turbolinux']
|
|
DEB_DISTRO_LIST = ['debian', 'ubuntu', 'Ubuntu']
|
|
|
|
# Server urls
|
|
SERVER_URL = "http://dev-builds.libreoffice.org"
|
|
|
|
# Local dirs
|
|
root_dir = os.getcwd()
|
|
DOWNLOAD_DIR = os.path.join(root_dir, "_download")
|
|
USR_DIR = os.path.join(root_dir, "_libo_smoke_user")
|
|
LOCAL_BUILD_INFO_FILE = "build.cfg"
|
|
|
|
ROOT_DIR_LIB = os.path.join(root_dir, 'lib')
|
|
ROOT_DIR_LIB32 = os.path.join(root_dir, 'lib32')
|
|
ROOT_DIR_LIB64 = os.path.join(root_dir, 'lib64')
|
|
ROOT_DIR_BIN32 = os.path.join(root_dir, 'bin32')
|
|
ROOT_DIR_BIN64 = os.path.join(root_dir, 'bin64')
|
|
|
|
CPPUNITTESTER = os.path.join(root_dir, 'cppunittester')
|
|
|
|
# INSTALL_DIR = os.path.join(root_dir, "_libo_smoke_installation")
|
|
INSTALL_DIR = "" # Installation dir
|
|
|
|
# SOFFICE_BIN bin
|
|
if platform.system() == "Linux":
|
|
SOFFICE_BIN= INSTALL_DIR + os.sep + "opt" + os.sep + install_dirname + os.sep + "program" + os.sep + "soffice"
|
|
|
|
# Relative build url
|
|
## pre-releases
|
|
PR_RPM_X86_PATH = "pre-releases/rpm/x86/"
|
|
PR_RPM_X86_64_PATH = "pre-releases/rpm/x86_64/"
|
|
|
|
PR_DEB_X86_PATH = "pre-releases/deb/x86/"
|
|
PR_DEB_X86_64_PATH = "pre-releases/deb/x86_64/"
|
|
|
|
PR_MAC_X86_PATH = "pre-releases/mac/x86/"
|
|
PR_MAC_PPC_PATH = "pre-releases/mac/ppc/"
|
|
|
|
PR_WIN_X86_PATH = "pre-releases/win/x86/"
|
|
|
|
## daily_master
|
|
DAILY_MASTER_RPM_X86_PATH = "daily/Linux_x86_Release_Configuration/master/current"
|
|
DAILY_MASTER_RPM_X86_64_PATH = "daily/Linux_x86_64_Release_Configuration/master/current"
|
|
|
|
DAILY_MASTER_DEB_X86_PATH = "daily/Linux_x86_Release_Configuration/master/current"
|
|
DAILY_MASTER_DEB_X86_64_PATH = "daily/Linux_x86_64_Release_Configuration/master/current" # No build yet
|
|
|
|
DAILY_MASTER_MAC_X86_PATH = "daily/MacOSX_10.6.7_Intel_no-moz/master/current"
|
|
DAILY_MASTER_MAC_PPC_PATH = "^$" # No build yet
|
|
|
|
DAILY_MASTER_WIN_X86_PATH = "daily/Windows_Release_Configuration/master/current"
|
|
|
|
## daily_branch
|
|
DAILY_BRANCH_RPM_X86_PATH = "daily/Linux_x86_Release_Configuration/libreoffice-" + tag_version + "/current"
|
|
DAILY_BRANCH_RPM_X86_64_PATH = "daily/Linux_x86_64_Release_Configuration/libreoffice-" + tag_version + "/current"
|
|
|
|
DAILY_BRANCH_DEB_X86_PATH = "daily/Linux_x86_Release_Configuration/libreoffice-" + tag_version + "/current"
|
|
DAILY_BRANCH_DEB_X86_64_PATH = "daily/Linux_x86_64_Release_Configuration/libreoffice-" + tag_version + "/current"
|
|
|
|
DAILY_BRANCH_MAC_X86_PATH = "daily/MacOSX_10.6.7_Intel_no-moz/libreoffice-" + tag_version + "/current"
|
|
DAILY_BRANCH_MAC_PPC_PATH = "^$" # No build yet
|
|
|
|
DAILY_BRANCH_WIN_X86_PATH = "daily/Windows_Release_Configuration/libreoffice-" + tag_version + "/current"
|
|
|
|
|
|
|
|
def platform_info():
|
|
|
|
s = platform.system()
|
|
arch_name = platform.machine()
|
|
|
|
if arch_name in ['x86', 'i386', 'i586', 'i686']:
|
|
arch_name = 'x86'
|
|
|
|
if s == "Linux":
|
|
if platform.dist()[0] in RPM_DISTRO_LIST:
|
|
distro_name = platform.dist()[0]
|
|
pck_name = 'rpm'
|
|
elif platform.dist()[0] in DEB_DISTRO_LIST:
|
|
distro_name = platform.dist()[0]
|
|
pck_name = 'deb'
|
|
elif s == "Windows":
|
|
distro_name = platform.dist()[0]
|
|
pck_name = 'exe'
|
|
else:
|
|
distro_name = platform.dist()[0]
|
|
pck_name = 'dmg'
|
|
|
|
return distro_name, pck_name, arch_name
|
|
|
|
def local_build_info(t):
|
|
|
|
if not os.path.exists(LOCAL_BUILD_INFO_FILE):
|
|
logger.error("Can't find the file: " + LOCAL_BUILD_INFO_FILE)
|
|
sys.exit()
|
|
|
|
config = configparser.RawConfigParser()
|
|
config.read(LOCAL_BUILD_INFO_FILE)
|
|
|
|
try:
|
|
build_name = config.get(t, 'build_name').strip('\n')
|
|
build_time = datetime.datetime.strptime(config.get(t, 'build_time').strip('\n'), '%d-%b-%Y %H:%M')
|
|
except ValueError:
|
|
build_name = ''
|
|
build_time = datetime.datetime.min
|
|
|
|
return build_name, build_time
|
|
|
|
def get_url_regexp(t, package, arch):
|
|
'''
|
|
return a url containing download links, i.e:
|
|
|
|
http://dev-builds.libreoffice.org/pre-releases/rpm/x86_64/
|
|
http://dev-builds.libreoffice.org/daily/Windows_Release_Configuration/libreoffice-3-4/current/
|
|
http://dev-builds.libreoffice.org/daily/Linux_x86_Release_Configuration/libreoffice-3-4/current/
|
|
|
|
meanwhile return a regexp object that matching corresponding downloadable
|
|
package and its timestamp '''
|
|
|
|
url = ""
|
|
reg = re.compile('^$')
|
|
pck = package
|
|
arc = arch
|
|
|
|
if t == 'pre-releases':
|
|
if pck == "rpm" and arc == "x86":
|
|
url = SERVER_URL + "/" + PR_RPM_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*x86_install-rpm.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "rpm" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + PR_RPM_X86_64_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*x86-64_install-rpm.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86":
|
|
url = SERVER_URL + "/" + PR_DEB_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*x86_install-deb.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + PR_DEB_X86_64_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*x86-64_install-deb.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "exe" and arc == "x86":
|
|
url = SERVER_URL + "/" + PR_WIN_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*Win_x86_install_multi.exe)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "dmg" and arc == "x86":
|
|
url = SERVER_URL + "/" + PR_MAC_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*MacOS_x86_install_en-US.dmg)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "dmg" and arc == "ppc":
|
|
url = SERVER_URL + "/" + PR_MAC_PPC_PATH
|
|
reg = re.compile('\<a\ href=\"(LibO_\d.*MacOS_PPC_install_en-US.dmg)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
else:
|
|
logger.error("Unable to handle the system or arch!")
|
|
elif t == 'daily_master':
|
|
if pck == "rpm" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_RPM_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(master\~\d.*LibO-Dev_.*x86_install-rpm_en-US.tar.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "rpm" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_RPM_X86_64_PATH
|
|
reg = re.compile('\<a\ href=\"(master\~\d.*LibO-Dev_.*x86-64_install-rpm_en-US.tar.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_DEB_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(master\~\d.*LibO-Dev_.*x86_install-deb_en-US.tar.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_DEB_X86_64_PATH
|
|
reg = re.compile('^$') # No build yet
|
|
elif pck == "exe" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_WIN_X86_PATH
|
|
reg = re.compile('^$') # No build yet
|
|
elif pck == "dmg" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_MAC_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(master\~\d.*LibO-Dev_.*x86_install_en-US.dmg)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "dmg" and arc == "ppc":
|
|
url = SERVER_URL + "/" + DAILY_MASTER_MAC_PPC_PATH
|
|
reg = re.compile('^$') # No build yet
|
|
else:
|
|
logger.error("Unable to handle the system or arch!")
|
|
elif t == 'daily_branch':
|
|
if pck == "rpm" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_RPM_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(.*LibO_.*x86_install-rpm_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "rpm" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_RPM_X86_64_PATH
|
|
reg = re.compile('\<a\ href=\"(.*LibO_.*x86-64_install-rpm_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_DEB_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(.*LibO_.*x86_install-deb_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "deb" and arc == "x86_64":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_DEB_X86_64_PATH
|
|
reg = re.compile('\<a\ href=\"(.*LibO_.*x86-64_install-deb_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "exe" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_WIN_X86_PATH
|
|
reg = re.compile('\<a\ href=\"(.*LibO_.*install_.*\.exe)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
|
|
elif pck == "dmg" and arc == "x86":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_MAC_X86_PATH
|
|
reg = re.compile('^$') # No build yet
|
|
elif pck == "dmg" and arc == "ppc":
|
|
url = SERVER_URL + "/" + DAILY_BRANCH_MAC_PPC_PATH
|
|
reg = re.compile('^$') # No build yet
|
|
else:
|
|
logger.error("Unable to handle the system or arch!")
|
|
else:
|
|
logger.error("Error build type! The build type has to be:\n pre-releases, daily_master, daily_branch")
|
|
|
|
return url, reg
|
|
|
|
def remote_build_info(url_reg):
|
|
''' Get the latest proper build info (build_name, build_time) from
|
|
url. '''
|
|
|
|
p = platform_info()
|
|
pck = p[1]
|
|
arc = p[2]
|
|
r = url_reg[1]
|
|
|
|
f = urllib2.urlopen(url_reg[0])
|
|
c = ''.join(f.readlines())
|
|
f.close()
|
|
|
|
build_list = r.findall(c)
|
|
|
|
build_name = ''
|
|
build_time = datetime.datetime.min
|
|
|
|
for b in build_list:
|
|
if datetime.datetime.strptime(b[1] + ' ' + b[2], '%d-%b-%Y %H:%M') > build_time:
|
|
build_name = b[0]
|
|
try:
|
|
build_time = datetime.datetime.strptime(b[1] + ' ' + b[2], '%d-%b-%Y %H:%M')
|
|
except:
|
|
print "remote_build_info: wrong time date&format"
|
|
|
|
return build_name, build_time
|
|
|
|
# return True when something was downloaded
|
|
def download(url_reg, build_type):
|
|
logger.info('Checking new build ...')
|
|
|
|
try:
|
|
remote_build = remote_build_info(url_reg)
|
|
local_build = local_build_info(build_type)
|
|
|
|
# print 'remote_build[1]=' + remote_build[1].isoformat()
|
|
# print 'local_build[1]=' + local_build[1].isoformat()
|
|
if remote_build[1] > local_build[1]:
|
|
logger.info('Found New build: ' + remote_build[0])
|
|
if fetch_build(url_reg[0], remote_build[0]):
|
|
set_build_config(build_type, 'build_name', remote_build[0])
|
|
set_build_config(build_type, 'build_time', datetime.datetime.strftime(remote_build[1], '%d-%b-%Y %H:%M'))
|
|
else:
|
|
logger.error('Download build failed!')
|
|
else:
|
|
return False
|
|
|
|
except urllib2.URLError, HTTPError:
|
|
logger.error('Error fetch remote build info.')
|
|
return False
|
|
except KeyboardInterrupt:
|
|
sys.exit()
|
|
except:
|
|
print "Some Error"
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def fetch_build(url, filename):
|
|
''' Download a build from address url/filename '''
|
|
|
|
logger.info("Downloading ... " + filename)
|
|
|
|
u = urllib2.urlopen(url + '/' + filename)
|
|
|
|
try:
|
|
f = open(DOWNLOAD_DIR + '/' + filename, 'wb')
|
|
f.write(u.read())
|
|
finally:
|
|
f.close()
|
|
|
|
return True
|
|
|
|
def set_build_config(section, option, value):
|
|
|
|
config = configparser.RawConfigParser()
|
|
config.readfp(open(LOCAL_BUILD_INFO_FILE))
|
|
config.set(section, option, value)
|
|
with open(LOCAL_BUILD_INFO_FILE, 'wb') as cfgfile:
|
|
config.write(cfgfile)
|
|
|
|
def uninstall():
|
|
''' Kill libreoffice processes and uninstall all previously installed
|
|
libreoffice packages '''
|
|
|
|
logger.info("Uninstalling ...")
|
|
|
|
pck = platform_info()[1]
|
|
|
|
if pck == 'rpm':
|
|
cmd_query = ["rpm", "-qa"]
|
|
cmd_filter = ["grep", "-e", branding_pack+build_version, "-e", basis_pack+build_version, "-e", ure_pack+build_version]
|
|
|
|
P_query = subprocess.Popen(cmd_query, stdout = subprocess.PIPE)
|
|
P_filter = subprocess.Popen(cmd_filter, stdin = P_query.stdout, stdout = subprocess.PIPE)
|
|
P_query.stdout.close() # protection when P_filter exit before P_query
|
|
str_filter = P_filter.communicate()[0]
|
|
|
|
if str_filter == "":
|
|
logger.warning("Nothing to uninstall")
|
|
return
|
|
else:
|
|
cmd = ["sudo", "rpm", "-e"] + str_filter.split()
|
|
elif pck == 'deb':
|
|
cmd_query = ["dpkg", "--get-selections", branding_pack+build_version+"*", basis_pack+build_version+"*", ure_pack+build_version+"*"]
|
|
cmd_filter = ["cut", "-f", "1"]
|
|
|
|
P_query = subprocess.Popen(cmd_query, stdout = subprocess.PIPE)
|
|
P_filter = subprocess.Popen(cmd_filter, stdin = P_query.stdout, stdout = subprocess.PIPE)
|
|
P_query.stdout.close()
|
|
str_filter = P_filter.communicate()[0]
|
|
|
|
if str_filter == "":
|
|
logger.warning("Nothing to uninstall")
|
|
return
|
|
else:
|
|
cmd = ["sudo", "dpkg ", "-P"] + str_filter.split()
|
|
elif pck == 'exe':
|
|
pass
|
|
elif pck == 'dmg':
|
|
pass
|
|
else:
|
|
logger.warning("Non supported package system")
|
|
|
|
subprocess.check_call(cmd)
|
|
|
|
def init_testing():
|
|
logger.info("Initializing ...")
|
|
|
|
post_testing()
|
|
|
|
if not os.path.exists(DOWNLOAD_DIR):
|
|
os.mkdir(DOWNLOAD_DIR)
|
|
|
|
if not os.path.exists(USR_DIR):
|
|
os.mkdir(USR_DIR)
|
|
|
|
# create set up links
|
|
try:
|
|
if platform.system() == "Linux":
|
|
# remove old symlinks if they exists
|
|
for p in ROOT_DIR_LIB, CPPUNITTESTER:
|
|
if os.path.exists(p) and os.path.islink(p):
|
|
os.remove(p)
|
|
|
|
if platform_info()[2] == "x86":
|
|
os.symlink(ROOT_DIR_LIB32, ROOT_DIR_LIB)
|
|
os.symlink(os.path.join(ROOT_DIR_BIN32, 'cppunittester'), CPPUNITTESTER)
|
|
elif platform_info()[2] == "x86_64":
|
|
os.symlink(ROOT_DIR_LIB64, ROOT_DIR_LIB)
|
|
os.symlink(os.path.join(ROOT_DIR_BIN64, 'cppunittester'), CPPUNITTESTER)
|
|
else:
|
|
pass
|
|
|
|
elif platform.system() == "Windows" and platform_info()[2] == "x86":
|
|
pass
|
|
else:
|
|
pass
|
|
|
|
except OSError:
|
|
pass
|
|
|
|
def post_testing():
|
|
logger.info("Cleaning up ...")
|
|
|
|
# clean up the extracted installer dir
|
|
for r in os.walk(DOWNLOAD_DIR):
|
|
if r[0] == DOWNLOAD_DIR:
|
|
for d in r[1]:
|
|
shutil.rmtree(os.path.join(r[0], d))
|
|
|
|
def install(filename):
|
|
''' filename: local file path of tar.gz, dmg or exe. The script will
|
|
extract the package and then install it '''
|
|
|
|
logger.info("Installing ... " + filename)
|
|
|
|
def _is_not_filtered(s):
|
|
''' True if the package s is not intended to installed. '''
|
|
filter_pattern_list = ['.*kde.*', '.*gnome.*', '.*desktop.*', '!.*\.rpm$', '!.*\.deb$']
|
|
for p in filter_pattern_list:
|
|
r = re.compile(p)
|
|
if r.match(s):
|
|
return False
|
|
return True
|
|
|
|
fn, ext = os.path.splitext(filename)
|
|
pcklist = []
|
|
|
|
if ext == '.exe':
|
|
# extract
|
|
installer_dir = os.path.join(DOWNLOAD_DIR, filename.strip(ext))
|
|
subprocess.check_call([filename, '/EXTRACTONLY=ON', '/S', '/D='+installer_dir])
|
|
# install
|
|
installer = glob.glob(os.path.join(installer_dir, 'libreoffice*msi'))[0]
|
|
subprocess.check_call(['msiexec', '-i', installer, '-passive', 'ADDLOCAL=all'])
|
|
elif ext == '.dmg':
|
|
return
|
|
elif ext == '.gz':
|
|
# extract
|
|
subprocess.check_call(['tar', 'xzf', filename, '-C', DOWNLOAD_DIR])
|
|
|
|
# get a filtered install list
|
|
for root, dirs, files in os.walk(DOWNLOAD_DIR):
|
|
if 'RPMS' in root or 'DEBS' in root:
|
|
pcklist = pcklist + [os.path.join(root_dir, root, f) for f in files]
|
|
pcklist = filter(_is_not_filtered, pcklist)
|
|
|
|
# install
|
|
if platform_info()[1] == 'rpm':
|
|
install_cmd = ["sudo", "rpm", "-iv"] + pcklist
|
|
elif platform_info()[1] == 'deb':
|
|
install_cmd = ["sudo", "dpkg", "-i"] + pcklist
|
|
else:
|
|
logger.error('Cannot generate install command')
|
|
return
|
|
|
|
subprocess.check_call(install_cmd)
|
|
|
|
else:
|
|
logger.info("Unrecognized file extension")
|
|
|
|
def verify_smoketest(headless):
|
|
logger.info("Testing ...")
|
|
|
|
s = platform.system()
|
|
p = platform_info()
|
|
pck = p[1]
|
|
arc = p[2]
|
|
|
|
if s == "Linux":
|
|
if headless:
|
|
os.environ['SAL_USE_VCLPLUGIN'] = "svp"
|
|
os.environ['LD_LIBRARY_PATH'] = ""
|
|
os.environ['LD_LIBRARY_PATH'] = ':'.join([os.path.join(root_dir, 'lib'), INSTALL_DIR + '/opt/' + install_dirname + '/ure/lib', os.environ['LD_LIBRARY_PATH']])
|
|
cmd_cppu = [
|
|
CPPUNITTESTER,
|
|
"-env:UNO_SERVICES=file://"+ INSTALL_DIR + "/opt/" + install_dirname + "/ure/share/misc/services.rdb",
|
|
"-env:UNO_TYPES=" + os.path.join(os.path.join(root_dir, 'lib'), "types.rdb"),
|
|
"-env:arg-soffice=path:" + SOFFICE_BIN,
|
|
"-env:arg-user=" + USR_DIR,
|
|
"-env:arg-env=" + os.environ['LD_LIBRARY_PATH'],
|
|
"-env:arg-testarg.smoketest.doc=" + os.path.join(root_dir, "doc/smoketestdoc.sxw"),
|
|
"--protector",
|
|
os.path.join(root_dir, "lib/unoexceptionprotector.so"), "unoexceptionprotector",
|
|
os.path.join(root_dir, "lib/libsmoketest.so")
|
|
]
|
|
else:
|
|
logger.warning('The smoketest does not support this platform yet!')
|
|
|
|
try:
|
|
subprocess.check_call(cmd_cppu)
|
|
logger.info(" Smoketest PASSED")
|
|
except:
|
|
logger.error(" Smoketest FAILED")
|
|
|
|
|
|
def usage():
|
|
|
|
print "\n[Usage]\n\n -f Force testing without asking \n\
|
|
-t Testing type pre-release/daily \n\
|
|
-l Download and test last builds in a loop \n\
|
|
-v Run smoketest verification directly \n\
|
|
-s Use the headless mode when running the tests \n\
|
|
-i Install the latest build in the DOWNLOAD directory \n\
|
|
-u Uninstall any existed libreoffice build \n\
|
|
-d Download the latest build for the given test type \n\
|
|
"
|
|
|
|
def main():
|
|
|
|
interactive = True
|
|
build_type = "pre-releases"
|
|
|
|
package_type = platform_info()[1]
|
|
arch_type = platform_info()[2]
|
|
|
|
loop = False
|
|
interactive = True
|
|
headless = False
|
|
build_type = "pre-releases"
|
|
|
|
# Handling options and arguments
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], "dluihfvst:", ["download", "loop", "uninstall", "install", "help", "force", "verify", "headless", "type="])
|
|
except getopt.GetoptError, err:
|
|
logger.error(str(err))
|
|
usage()
|
|
sys.exit(2)
|
|
|
|
for o, a in opts:
|
|
if ("-t" in o) or ("--type" in o):
|
|
build_type = a
|
|
elif o in ("-s", "--headless"):
|
|
headless = True
|
|
|
|
url_reg = get_url_regexp(build_type, package_type, arch_type)
|
|
|
|
for o, a in opts:
|
|
if o in ("-f", "--force"):
|
|
interactive = False
|
|
elif o in ("-t", "--type"):
|
|
pass
|
|
elif o in ("-s", "--headless"):
|
|
pass
|
|
elif o in ("-h", "--help"):
|
|
usage()
|
|
sys.exit()
|
|
elif o in ("-v", "--verify"):
|
|
init_testing()
|
|
verify_smoketest(headless)
|
|
sys.exit()
|
|
elif o in ("-i", "--install"):
|
|
init_testing()
|
|
uninstall()
|
|
install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[0])
|
|
sys.exit()
|
|
elif o in ("-u", "--uninstall"):
|
|
uninstall()
|
|
sys.exit()
|
|
elif o in ("-d", "--download"):
|
|
download(url_reg, build_type)
|
|
sys.exit()
|
|
elif o in ("-l", "--loop"):
|
|
loop = True
|
|
else:
|
|
assert False, "Unhandled option: " + o
|
|
|
|
if interactive == True:
|
|
key = raw_input("The testing will OVERRIDE existed libreoffice, continue(y/N)? ")
|
|
if not (key == "y" or key == "Y" or key == "yes"):
|
|
sys.exit()
|
|
|
|
init_testing()
|
|
first_run = True
|
|
while loop or first_run:
|
|
if download(url_reg, build_type):
|
|
try:
|
|
# FIXME: uninstall script fails but it need not break the whole game; so try it twice
|
|
try:
|
|
uninstall()
|
|
except:
|
|
logger.error("Some errors happend during uninstall. Trying once again.")
|
|
uninstall()
|
|
|
|
install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[0])
|
|
verify_smoketest(headless)
|
|
|
|
except KeyboardInterrupt:
|
|
sys.exit()
|
|
except:
|
|
pass
|
|
|
|
if loop:
|
|
time.sleep(build_check_interval)
|
|
|
|
first_run = False
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
# logging
|
|
logger = logging.getLogger('')
|
|
logger.setLevel(logging.DEBUG)
|
|
|
|
fh = logging.FileHandler('losmoketest.log')
|
|
ch = logging.StreamHandler()
|
|
|
|
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
|
|
ch.setFormatter(formatter)
|
|
fh.setFormatter(formatter)
|
|
|
|
logger.addHandler(ch)
|
|
logger.addHandler(fh)
|
|
|
|
main()
|