PageRenderTime 46ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/libreoffice-3.6.0.2/smoketest/lodownloadtest.py

#
Python | 681 lines | 627 code | 9 blank | 45 comment | 2 complexity | 5270e1207e4f075eb8adab024be52613 MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, LGPL-3.0 
    

  1. #!/usr/bin/env python
    2. 

  2. 

  3. # Version: MPL 1.1 / GPLv3+ / LGPLv3+
    4. 

  4. #
    5. 

  5. # The contents of this file are subject to the Mozilla Public License Version
    6. 

  6. # 1.1 (the "License"); you may not use this file except in compliance with
    7. 

  7. # the License or as specified alternatively below. You may obtain a copy of
    8. 

  8. # the License at http://www.mozilla.org/MPL/
    9. 

  9. #
    10. 

  10. # Software distributed under the License is distributed on an "AS IS" basis,
    11. 

  11. # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    12. 

  12. # for the specific language governing rights and limitations under the
    13. 

  13. # License.
    14. 

  14. #
    15. 

  15. # Major Contributor(s):
    16. 

  16. # [ Copyright (C) 2011 Yifan Jiang <yfjiang@suse.com> (initial developer) ]
    17. 

  17. # [ Copyright (C) 2011 Petr Mladek <pmladek@suse.cz> ]
    18. 

  18. #
    19. 

  19. # All Rights Reserved.
    20. 

  20. #
    21. 

  21. # For minor contributions see the git repository.
    22. 

  22. #
    23. 

  23. # Alternatively, the contents of this file may be used under the terms of
    24. 

  24. # either the GNU General Public License Version 3 or later (the "GPLv3+"), or
    25. 

  25. # the GNU Lesser General Public License Version 3 or later (the "LGPLv3+"),
    26. 

  26. # in which case the provisions of the GPLv3+ or the LGPLv3+ are applicable
    27. 

  27. # instead of those above.
    28. 

  28. ##
    29. 

  29. # The tool is designed to enable test machine fully automatically run smoketest
    30. 

  30. # with both daily and pre release build located in dev-build.libreoffice.org.
    31. 

  31. #
    32. 

  32. # The tool is named as losmoketest for its purpose, meanwhile it help you to
    33. 

  33. # check, download and install the latest build. By the fact the installation is
    34. 

  34. # designed not to be different from manually doing these repeated work, the
    35. 

  35. # installed libreoffice build can also be good for manual test.
    36. 

  36. 

  37. import sys, os, platform
    38. 

  38. import datetime, time
    39. 

  39. import subprocess, shutil
    40. 

  40. import glob, re
    41. 

  41. import urllib, urllib2
    42. 

  42. import logging, getopt
    43. 

  43. try:
    44. 

  44.     import ConfigParser as configparser # Python 3.0 change
    45. 

  45. except ImportError:
    46. 

  46.     import configparser
    47. 

  47. 

  48. # FIXME: make this configurable via options or autodetect it
    49. 

  49. build_version = "3.5"
    50. 

  50. tag_version = "3-5"
    51. 

  51. # devel build
    52. 

  52. branding_pack="lodev"
    53. 

  53. basis_pack="lodevbasis"
    54. 

  54. # stable build
    55. 

  55. #branding_pack="libreoffice"
    56. 

  56. #basis_pack="libobasis"
    57. 

  57. 

  58. # possible program files of libreoffice, put all platform paths are
    59. 

  59. # expected in this list
    60. 

  60. lo_all_paths = [
    61. 

  61.     "/opt/lodev" + build_version, \
    62. 

  62.     "/opt/libreoffice" + build_version, \
    63. 

  63.     "/usr/lib/libreoffice", \
    64. 

  64.     "/usr/lib64/libreoffice", \
    65. 

  65.     "C:\program file\libreoffice", \
    66. 

  66.     ]
    67. 

  67. 

  68. build_check_interval = 5  #seconds
    69. 

  69. 

  70. # Distro list
    71. 

  71. RPM_DISTRO_LIST = ['SuSE', 'fedora', 'redhat', 'centos', 'mandrake', 'mandriva', 'yellowdog', 'turbolinux']
    72. 

  72. DEB_DISTRO_LIST = ['debian', 'ubuntu', 'Ubuntu']
    73. 

  73. 

  74. # Server urls
    75. 

  75. SERVER_URL = "http://dev-builds.libreoffice.org"
    76. 

  76. 

  77. # Local dirs
    78. 

  78. root_dir = os.getcwd()
    79. 

  79. DOWNLOAD_DIR = os.path.join(root_dir, "_download")
    80. 

  80. USR_DIR = os.path.join(root_dir, "_libo_smoke_user")
    81. 

  81. LOCAL_BUILD_INFO_FILE = os.path.join(root_dir, "build.cfg")
    82. 

  82. 

  83. # INSTALL_DIR = os.path.join(root_dir, "_libo_smoke_installation")
    84. 

  84. INSTALL_DIR = "" # Installation dir
    85. 

  85. 

  86. # SOFFICE_BIN bin
    87. 

  87. if platform.system() == "Linux":
    88. 

  88.     SOFFICE_BIN = "soffice"
    89. 

  89.     LOSMOKETEST_BIN = "losmoketest"
    90. 

  90. elif platform.system() == "Windows":
    91. 

  91.     SOFFICE_BIN = "soffice.exe"
    92. 

  92.     LOSMOKETEST_BIN = "losmoketest"
    93. 

  93. else:
    94. 

  94.     SOFFICE_BIN = "soffice"
    95. 

  95.     LOSMOKETEST_BIN = "losmoketest"
    96. 

  96. 

  97. # Relative build url
    98. 

  98. ## pre-releases
    99. 

  99. PR_RPM_X86_PATH = "pre-releases/rpm/x86/"
    100. 

  100. PR_RPM_X86_64_PATH = "pre-releases/rpm/x86_64/"
    101. 

  101. 

  102. PR_DEB_X86_PATH = "pre-releases/deb/x86/"
    103. 

  103. PR_DEB_X86_64_PATH = "pre-releases/deb/x86_64/"
    104. 

  104. 

  105. PR_MAC_X86_PATH = "pre-releases/mac/x86/"
    106. 

  106. PR_MAC_PPC_PATH = "pre-releases/mac/ppc/"
    107. 

  107. 

  108. PR_WIN_X86_PATH = "pre-releases/win/x86/"
    109. 

  109. 

  110. ## daily_master
    111. 

  111. DAILY_MASTER_RPM_X86_PATH =    "daily/Linux-x86_10-Release_Configuration/master/current"
    112. 

  112. DAILY_MASTER_RPM_X86_64_PATH = "daily/Linux-x86_64_11-Release_Configuration/master/current"
    113. 

  113. 

  114. DAILY_MASTER_DEB_X86_PATH =    "daily/Linux-x86_10-Release_Configuration/master/current"
    115. 

  115. DAILY_MASTER_DEB_X86_64_PATH = "daily/Linux-x86_64_11-Release_Configuration/master/current"
    116. 

  116. 

  117. DAILY_MASTER_MAC_X86_PATH =    "daily/MacOSX-Intel@3-OSX_10.6.0-gcc_4.0.1/master/current"
    118. 

  118. DAILY_MASTER_MAC_PPC_PATH =    "daily/MacOSX-PPC@12-OSX_10.5.0-gcc_4.0.1/master/current" # No build yet
    119. 

  119. 

  120. DAILY_MASTER_WIN_X86_PATH =    "daily/Win-x86@7-MinGW/master/current" # cross compling build
    121. 

  121. 

  122. ## daily_branch
    123. 

  123. DAILY_BRANCH_RPM_X86_PATH =    "daily/Linux-x86_10-Release_Configuration/libreoffice-" + tag_version + "/current"
    124. 

  124. DAILY_BRANCH_RPM_X86_64_PATH = "daily/Linux-x86_64_11-Release_Configuration/libreoffice-" + tag_version + "/current"
    125. 

  125. 

  126. DAILY_BRANCH_DEB_X86_PATH =    "daily/Linux-x86_10-Release_Configuration/libreoffice-" + tag_version + "/current"
    127. 

  127. DAILY_BRANCH_DEB_X86_64_PATH = "daily/Linux-x86_64_11-Release_Configuration/libreoffice-" + tag_version + "/current"
    128. 

  128. 

  129. DAILY_BRANCH_MAC_X86_PATH =    "daily/MacOSX-Intel@3-OSX_10.6.0-gcc_4.0.1/libreoffice-" + tag_version + "/current"
    130. 

  130. DAILY_BRANCH_MAC_PPC_PATH =    "daily/MacOSX-PPC@12-OSX_10.5.0-gcc_4.0.1/libreoffice-" + tag_version + "/current"
    131. 

  131. 

  132. DAILY_BRANCH_WIN_X86_PATH =    "daily/Win-x86@7-MinGW/libreoffice-" + tag_version + "/current"
    133. 

  133. 

  134. 

  135. 

  136. def platform_info():
    137. 

  137. 

  138.     s = platform.system()
    139. 

  139.     arch_name = platform.machine()
    140. 

  140. 

  141.     if arch_name in ['x86', 'i386', 'i586', 'i686']:
    142. 

  142.         arch_name = 'x86'
    143. 

  143. 

  144.     if s == "Linux":
    145. 

  145.         if platform.dist()[0] in RPM_DISTRO_LIST:
    146. 

  146.             distro_name = platform.dist()[0]
    147. 

  147.             pck_name = 'rpm'
    148. 

  148.         elif platform.dist()[0] in DEB_DISTRO_LIST:
    149. 

  149.             distro_name = platform.dist()[0]
    150. 

  150.             pck_name = 'deb'
    151. 

  151.     elif s == "Windows":
    152. 

  152.         distro_name = platform.dist()[0]
    153. 

  153.         pck_name = 'exe'
    154. 

  154.     else:
    155. 

  155.         distro_name = platform.dist()[0]
    156. 

  156.         pck_name = 'dmg'
    157. 

  157. 

  158.     return distro_name, pck_name, arch_name
    159. 

  159. 

  160. def local_build_info(t):
    161. 

  161. 

  162.     if not os.path.exists(LOCAL_BUILD_INFO_FILE):
    163. 

  163.         logger.error("Can't find the file: " + LOCAL_BUILD_INFO_FILE)
    164. 

  164.         sys.exit()
    165. 

  165. 

  166.     config = configparser.RawConfigParser()
    167. 

  167.     config.read(LOCAL_BUILD_INFO_FILE)
    168. 

  168. 

  169.     try:
    170. 

  170.         build_name = config.get(t, 'build_name').strip('\n')
    171. 

  171.         build_time = datetime.datetime.strptime(config.get(t, 'build_time').strip('\n'), '%d-%b-%Y %H:%M')
    172. 

  172.     except ValueError:
    173. 

  173.         build_name = ''
    174. 

  174.         build_time = datetime.datetime.min
    175. 

  175. 

  176.     try:
    177. 

  177.         testpack_name = config.get(t, 'testpack_name').strip('\n')
    178. 

  178.         testpack_build_time = datetime.datetime.strptime(config.get(t, 'testpack_build_time').strip('\n'), '%d-%b-%Y %H:%M')
    179. 

  179.     except ValueError:
    180. 

  180.         testpack_name = ''
    181. 

  181.         testpack_build_time = datetime.datetime.min
    182. 

  182. 

  183.     return build_name, build_time, testpack_name, testpack_build_time
    184. 

  184. 

  185. def get_url_regexp(t, package, arch):
    186. 

  186.     '''
    187. 

  187.     return a url containing download links, i.e:
    188. 

  188. 

  189.         http://dev-builds.libreoffice.org/pre-releases/rpm/x86_64/
    190. 

  190.         http://dev-builds.libreoffice.org/daily/Windows_Release_Configuration/libreoffice-3-4/current/
    191. 

  191.         http://dev-builds.libreoffice.org/daily/Linux_x86_Release_Configuration/libreoffice-3-4/current/
    192. 

  192. 

  193.     meanwhile return a regexp object that matching corresponding downloadable
    194. 

  194.     package and its timestamp '''
    195. 

    196. 

  196.     url = ""
    197. 

  197.     reg_lo = re.compile('^$')
    198. 

  198.     reg_tst = re.compile('^$')
    199. 

  199.     pck = package
    200. 

  200.     arc = arch
    201. 

  201. 

  202.     if t == 'pre-releases':
    203. 

  203.         if pck == "rpm" and arc == "x86":
    204. 

  204.             url = SERVER_URL + "/" + PR_RPM_X86_PATH
    205. 

  205.             reg_lo = re.compile('\<a\ href=\"(LibO_\d.*x86_install-rpm.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    206. 

  206.             reg_tst = re.compile('\<a\ href=\"(LibO-Test.*.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    207. 

  207.         elif pck == "rpm" and arc == "x86_64":
    208. 

  208.             url = SERVER_URL + "/" + PR_RPM_X86_64_PATH
    209. 

  209.             reg_lo = 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}).*')
    210. 

  210.             reg_tst = re.compile('\<a\ href=\"(LibO-Test.*.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    211. 

  211.         elif pck == "deb" and arc == "x86":
    212. 

  212.             url = SERVER_URL + "/" + PR_DEB_X86_PATH
    213. 

  213.             reg_lo = re.compile('\<a\ href=\"(LibO_\d.*x86_install-deb.*en-US.*\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    214. 

  214.         elif pck == "deb" and arc == "x86_64":
    215. 

  215.             url = SERVER_URL + "/" + PR_DEB_X86_64_PATH
    216. 

  216.             reg_lo = 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}).*')
    217. 

  217.         elif pck == "exe" and arc == "x86":
    218. 

  218.             url = SERVER_URL + "/" + PR_WIN_X86_PATH
    219. 

  219.             reg_lo = re.compile('\<a\ href=\"(LibO_\d.*Win_x86_install_multi.exe)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    220. 

  220.         elif pck == "dmg" and arc == "x86":
    221. 

  221.             url = SERVER_URL + "/" + PR_MAC_X86_PATH
    222. 

  222.             reg_lo = re.compile('\<a\ href=\"(LibO_\d.*MacOS_x86_install_en-US.dmg)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    223. 

  223.         elif pck == "dmg" and arc == "ppc":
    224. 

  224.             url = SERVER_URL + "/" + PR_MAC_PPC_PATH
    225. 

  225.             reg_lo = re.compile('\<a\ href=\"(LibO_\d.*MacOS_PPC_install_en-US.dmg)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    226. 

  226.         else:
    227. 

  227.             logger.error("Unable to handle the system or arch!")
    228. 

  228.     elif t == 'daily_master':
    229. 

  229.         if pck == "rpm" and arc == "x86":
    230. 

  230.             url = SERVER_URL + "/" + DAILY_MASTER_RPM_X86_PATH
    231. 

  231.             reg_lo = 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}).*')
    232. 

  232.         elif pck == "rpm" and arc == "x86_64":
    233. 

  233.             url = SERVER_URL + "/" + DAILY_MASTER_RPM_X86_64_PATH
    234. 

  234.             reg_lo = 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}).*')
    235. 

  235.         elif pck == "deb" and arc == "x86":
    236. 

  236.             url = SERVER_URL + "/" + DAILY_MASTER_DEB_X86_PATH
    237. 

  237.             reg_lo = 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}).*')
    238. 

  238.         elif pck == "deb" and arc == "x86_64":
    239. 

  239.             url = SERVER_URL + "/" + DAILY_MASTER_DEB_X86_64_PATH
    240. 

  240.             reg_lo = re.compile('^$') # No build yet
    241. 

  241.         elif pck == "exe" and arc == "x86":
    242. 

  242.             url = SERVER_URL + "/" + DAILY_MASTER_WIN_X86_PATH
    243. 

  243.             reg_lo = re.compile('^$') # No build yet
    244. 

  244.         elif pck == "dmg" and arc == "x86":
    245. 

  245.             url = SERVER_URL + "/" + DAILY_MASTER_MAC_X86_PATH
    246. 

  246.             reg_lo = 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}).*')
    247. 

  247.         elif pck == "dmg" and arc == "ppc":
    248. 

  248.             url = SERVER_URL + "/" + DAILY_MASTER_MAC_PPC_PATH
    249. 

  249.             reg_lo = re.compile('^$') # No build yet
    250. 

  250.         else:
    251. 

  251.             logger.error("Unable to handle the system or arch!")
    252. 

  252.     elif t == 'daily_branch':
    253. 

  253.         if pck == "rpm" and arc == "x86":
    254. 

  254.             url = SERVER_URL + "/" + DAILY_BRANCH_RPM_X86_PATH
    255. 

  255.             reg_lo = re.compile('\<a\ href=\"(.*LibO_.*x86_install-rpm_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    256. 

  256.         elif pck == "rpm" and arc == "x86_64":
    257. 

  257.             url = SERVER_URL + "/" + DAILY_BRANCH_RPM_X86_64_PATH
    258. 

  258.             reg_lo = 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}).*')
    259. 

  259.         elif pck == "deb" and arc == "x86":
    260. 

  260.             url = SERVER_URL + "/" + DAILY_BRANCH_DEB_X86_PATH
    261. 

  261.             reg_lo = re.compile('\<a\ href=\"(.*LibO_.*x86_install-deb_en-US\.tar\.gz)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    262. 

  262.         elif pck == "deb" and arc == "x86_64":
    263. 

  263.             url = SERVER_URL + "/" + DAILY_BRANCH_DEB_X86_64_PATH
    264. 

  264.             reg_lo = 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}).*')
    265. 

  265.         elif pck == "exe" and arc == "x86":
    266. 

  266.             url = SERVER_URL + "/" + DAILY_BRANCH_WIN_X86_PATH
    267. 

  267.             reg_lo = re.compile('\<a\ href=\"(.*LibO_.*install_.*\.exe)\".*(\d{2}\-[a-zA-Z]{3}\-\d{4}).*(\d{2}:\d{2}).*')
    268. 

  268.         elif pck == "dmg" and arc == "x86":
    269. 

  269.             url = SERVER_URL + "/" + DAILY_BRANCH_MAC_X86_PATH
    270. 

  270.             reg_lo = re.compile('^$') # No build yet
    271. 

  271.         elif pck == "dmg" and arc == "ppc":
    272. 

  272.             url = SERVER_URL + "/" + DAILY_BRANCH_MAC_PPC_PATH
    273. 

  273.             reg_lo = re.compile('^$') # No build yet
    274. 

  274.         else:
    275. 

  275.             logger.error("Unable to handle the system or arch!")
    276. 

  276.     else:
    277. 

  277.         logger.error("Error build type! The build type has to be:\n pre-releases, daily_master, daily_branch")
    278. 

  278. 

  279.     return url, reg_lo, reg_tst
    280. 

  280. 

  281. def remote_build_info(url_reg):
    282. 

  282.     ''' Get the latest proper build info (build_name, build_time) from
    283. 

  283.     url. '''
    284. 

    285. 

  285.     p = platform_info()
    286. 

  286.     pck = p[1]
    287. 

  287.     arc = p[2]
    288. 

  288.     r = url_reg[1]
    289. 

  289.     r_t = url_reg[2]
    290. 

  290. 

  291.     f = urllib2.urlopen(url_reg[0])
    292. 

  292.     c = ''.join(f.readlines())
    293. 

  293.     f.close()
    294. 

  294. 

  295.     build_list = r.findall(c)
    296. 

  296.     test_list = r_t.findall(c)
    297. 

  297. 

  298.     build_name = ''
    299. 

  299.     build_time = datetime.datetime.min
    300. 

  300.     testpack_build_time = datetime.datetime.min
    301. 

  301.     testpack_name = ''
    302. 

  302. 

  303. 

  304.     for b in build_list:
    305. 

  305.         if datetime.datetime.strptime(b[1] + ' ' + b[2], '%d-%b-%Y %H:%M') > build_time:
    306. 

  306.             build_name = b[0]
    307. 

  307.             try:
    308. 

  308.                 build_time = datetime.datetime.strptime(b[1] + ' ' + b[2], '%d-%b-%Y %H:%M')
    309. 

  309.             except:
    310. 

  310.                 print "remote_build_info: wrong time date&format"
    311. 

  311. 

  312.     for t in test_list:
    313. 

  313.         if datetime.datetime.strptime(t[1] + ' ' + t[2], '%d-%b-%Y %H:%M') > testpack_build_time:
    314. 

  314.             testpack_name = t[0]
    315. 

  315.             try:
    316. 

  316.                 testpack_build_time = datetime.datetime.strptime(t[1] + ' ' + t[2], '%d-%b-%Y %H:%M')
    317. 

  317.             except:
    318. 

  318.                 print "remote_build_info: wrong time date&format"
    319. 

  319. 

  320.     return build_name, build_time, testpack_name, testpack_build_time
    321. 

  321. 

  322. # return True when something was downloaded
    323. 

  323. def download(url_reg, build_type):
    324. 

  324.     logger.info('Checking new build ...')
    325. 

  325. 

  326.     try:
    327. 

  327.         remote_build = remote_build_info(url_reg)
    328. 

  328.         local_build = local_build_info(build_type)
    329. 

  329. 

  330.         if remote_build[1] > local_build[1]:
    331. 

  331.             logger.info('Found New LO build: ' + remote_build[0])
    332. 

  332.             if fetch_build(url_reg[0], remote_build[0]):
    333. 

  333.                 set_build_config(build_type, 'build_name', remote_build[0])
    334. 

  334.                 set_build_config(build_type, 'build_time', datetime.datetime.strftime(remote_build[1], '%d-%b-%Y %H:%M'))
    335. 

  335.             else:
    336. 

  336.                 logger.error('Download libreoffice build failed!')
    337. 

  337. 

  338.         if remote_build[3] > local_build[3] and (remote_build[1] - remote_build[3]) < datetime.timedelta(hours=1):
    339. 

  339.             logger.info('Found a relevant smoketest package: ' + remote_build[2])
    340. 

  340.             if fetch_build(url_reg[0], remote_build[2]):
    341. 

  341.                 set_build_config(build_type, 'testpack_name', remote_build[2])
    342. 

  342.                 set_build_config(build_type, 'testpack_build_time', datetime.datetime.strftime(remote_build[3], '%d-%b-%Y %H:%M'))
    343. 

  343.                 return True
    344. 

  344.             else:
    345. 

  345.                 logger.warning("Failed to find corresponding smoketest package")
    346. 

  346. 

  347.     except urllib2.URLError, HTTPError:
    348. 

  348.         logger.error('Error fetch remote build info.')
    349. 

  349.         return False
    350. 

  350.     except KeyboardInterrupt:
    351. 

  351.         sys.exit()
    352. 

  352.     except:
    353. 

  353.         logger.error('Error fetch remote build info.')
    354. 

  354.         return False
    355. 

  355. 

  356.     return False
    357. 

  357. 

  358. def fetch_build(url, filename):
    359. 

  359.     ''' Download a build from address url/filename '''
    360. 

  360. 

  361.     logger.info("Downloading ... " + filename)
    362. 

  362. 

  363.     u = urllib2.urlopen(url + '/' + filename)
    364. 

  364. 

  365.     try:
    366. 

  366.         f = open(DOWNLOAD_DIR + '/' + filename, 'wb')
    367. 

  367.         f.write(u.read())
    368. 

  368.         f.close()
    369. 

  369.     except urllib2.HTTPError, e:
    370. 

  370.         print "HTTP Error:",e.code , url
    371. 

  371.     except urllib2.URLError, e:
    372. 

  372.         print "URL Error:",e.reason , url
    373. 

  373. 

  374.     return True
    375. 

  375. 

  376. def set_build_config(section, option, value):
    377. 

  377. 

  378.     config = configparser.RawConfigParser()
    379. 

  379.     config.readfp(open(LOCAL_BUILD_INFO_FILE))
    380. 

  380.     config.set(section, option, value)
    381. 

  381.     with open(LOCAL_BUILD_INFO_FILE, 'wb') as cfgfile:
    382. 

  382.         config.write(cfgfile)
    383. 

  383. 

  384. def uninstall(build_type):
    385. 

  385.     ''' Kill libreoffice processes and uninstall all previously installed
    386. 

  386.     libreoffice packages '''
    387. 

    388. 

  388.     if build_type == "pre-releases":
    389. 

  389.         branding_pack="libreoffice"
    390. 

  390.         basis_pack="libobasis"
    391. 

  391. 

  392.     logger.info("Uninstalling ...")
    393. 

  393. 

  394.     pck = platform_info()[1]
    395. 

  395. 

  396.     if pck == 'rpm':
    397. 

  397.         cmd_query  = ["rpm", "-qa"]
    398. 

  398.         cmd_filter = ["grep", \
    399. 

  399.                       "-e", branding_pack+build_version, \
    400. 

  400.                       "-e", basis_pack+build_version,  \
    401. 

  401.                       ]
    402. 

  402. 

  403.         P_query  = subprocess.Popen(cmd_query, stdout = subprocess.PIPE)
    404. 

  404.         P_filter = subprocess.Popen(cmd_filter, stdin = P_query.stdout, stdout = subprocess.PIPE)
    405. 

  405.         P_query.stdout.close() # protection when P_filter exit before P_query
    406. 

  406.         str_filter = P_filter.communicate()[0]
    407. 

  407. 

  408.         if str_filter == "":
    409. 

  409.             logger.warning("Nothing to uninstall")
    410. 

  410.             return
    411. 

  411.         else:
    412. 

  412.             cmd = ["sudo", "rpm", "-e"] + str_filter.split()
    413. 

  413.     elif pck == 'deb':
    414. 

  414.         cmd_query = ["dpkg", "--get-selections", branding_pack+build_version+"*", basis_pack+build_version+"*"]
    415. 

  415.         cmd_filter = ["cut", "-f", "1"]
    416. 

  416. 

  417.         P_query = subprocess.Popen(cmd_query, stdout = subprocess.PIPE)
    418. 

  418.         P_filter = subprocess.Popen(cmd_filter, stdin = P_query.stdout, stdout = subprocess.PIPE)
    419. 

  419.         P_query.stdout.close()
    420. 

  420.         str_filter = P_filter.communicate()[0]
    421. 

  421. 

  422.         if str_filter == "":
    423. 

  423.             logger.warning("Nothing to uninstall")
    424. 

  424.             return
    425. 

  425.         else:
    426. 

  426.             cmd = ["sudo", "dpkg ", "-P"] + str_filter.split()
    427. 

  427.     elif pck == 'exe':
    428. 

  428.         pass
    429. 

  429.     elif pck == 'dmg':
    430. 

  430.         pass
    431. 

  431.     else:
    432. 

  432.         logger.warning("Non supported package system")
    433. 

  433. 

  434.     subprocess.check_call(cmd)
    435. 

  435. 

  436. def init_testing():
    437. 

  437.     logger.info("Initializing ...")
    438. 

  438. 

  439.     post_testing()
    440. 

  440. 

  441.     if not os.path.exists(DOWNLOAD_DIR):
    442. 

  442.         os.mkdir(DOWNLOAD_DIR)
    443. 

  443. 

  444.     if not os.path.exists(USR_DIR):
    445. 

  445.         os.mkdir(USR_DIR)
    446. 

  446. 

  447.     if not os.path.exists(LOCAL_BUILD_INFO_FILE):
    448. 

  448. 

  449.         init_build_cfg = '[daily_branch]' + os.linesep\
    450. 

  450.                        + 'build_name =' + os.linesep\
    451. 

  451.                        + 'build_time =' + os.linesep\
    452. 

  452.                        + 'testpack_name =' + os.linesep\
    453. 

  453.                        + 'testpack_build_time =' + os.linesep\
    454. 

  454.                        + '[daily_master]' + os.linesep\
    455. 

  455.                        + 'build_name =' + os.linesep\
    456. 

  456.                        + 'build_time =' + os.linesep\
    457. 

  457.                        + 'testpack_name =' + os.linesep\
    458. 

  458.                        + 'testpack_build_time =' + os.linesep\
    459. 

  459.                        + '[pre-releases]' + os.linesep\
    460. 

  460.                        + 'build_name =' + os.linesep\
    461. 

  461.                        + 'build_time =' + os.linesep \
    462. 

  462.                        + 'testpack_name =' + os.linesep\
    463. 

  463.                        + 'testpack_build_time =' + os.linesep
    464. 

  464. 

  465.         with open(LOCAL_BUILD_INFO_FILE, 'w+') as f:
    466. 

  466.             f.write(init_build_cfg)
    467. 

  467.         f.close()
    468. 

  468. 

  469. def post_testing():
    470. 

  470.     logger.info("Cleaning up ...")
    471. 

  471. 

  472.     # clean up the extracted installer dir
    473. 

  473.     for r in os.walk(DOWNLOAD_DIR):
    474. 

  474.         if r[0] == DOWNLOAD_DIR:
    475. 

  475.             for d in r[1]:
    476. 

  476.                 shutil.rmtree(os.path.join(r[0], d))
    477. 

  477. 

  478. def install(filename):
    479. 

  479.     ''' filename: local file path of tar.gz, dmg or exe. The script will
    480. 

  480.     extract the package and then install it '''
    481. 

    482. 

  482.     logger.info("Installing ... " + filename)
    483. 

  483. 

  484.     def _is_not_filtered(s):
    485. 

  485.         ''' True if the package s is not intended to installed.  '''
    486. 

  486.         filter_pattern_list = ['.*kde.*', '.*gnome.*', '.*desktop.*', '!.*\.rpm$', '!.*\.deb$']
    487. 

  487.         for p in filter_pattern_list:
    488. 

  488.             r = re.compile(p)
    489. 

  489.             if r.match(s):
    490. 

  490.                 return False
    491. 

  491.         return True
    492. 

  492. 

  493.     fn, ext = os.path.splitext(filename)
    494. 

  494.     pcklist = []
    495. 

  495. 

  496.     if ext == '.exe':
    497. 

  497.         # extract
    498. 

  498.         installer_dir = os.path.join(DOWNLOAD_DIR, filename.strip(ext))
    499. 

  499.         subprocess.check_call([filename, '/EXTRACTONLY=ON', '/S', '/D='+installer_dir])
    500. 

  500.         # install
    501. 

  501.         installer = glob.glob(os.path.join(installer_dir, 'libreoffice*msi'))[0]
    502. 

  502.         subprocess.check_call(['msiexec', '-i', installer, '-passive', 'ADDLOCAL=all'])
    503. 

  503.     elif ext == '.dmg':
    504. 

  504.         return
    505. 

  505.     elif ext == '.gz':
    506. 

  506.         # extract
    507. 

  507.         subprocess.check_call(['tar', 'xzf', filename, '-C', DOWNLOAD_DIR])
    508. 

  508. 

  509.         # get a filtered install list
    510. 

  510.         for root, dirs, files in os.walk(DOWNLOAD_DIR):
    511. 

  511.             if 'RPMS' in root or 'DEBS' in root:
    512. 

  512.                 pcklist = pcklist + [os.path.join(root_dir, root, f) for f in files]
    513. 

  513.         install_pcklist = filter(_is_not_filtered, pcklist)
    514. 

  514. 

  515.         # install
    516. 

  516.         if platform_info()[1] == 'rpm':
    517. 

  517.             install_cmd = ["sudo", "rpm", "-iv"] + install_pcklist
    518. 

  518.             clean_tmp_cmd = ["sudo", "rm", "-f"] + pcklist
    519. 

  519.         elif platform_info()[1] == 'deb':
    520. 

  520.             install_cmd = ["sudo", "dpkg", "-i"] + install_pcklist
    521. 

  521.         else:
    522. 

  522.             logger.error('Cannot generate install command')
    523. 

  523.             return
    524. 

  524. 

  525.         subprocess.check_call(install_cmd)
    526. 

  526.         subprocess.check_call(clean_tmp_cmd)
    527. 

  527. 

  528.     else:
    529. 

  529.         logger.info("Unrecognized file extension")
    530. 

  530. 

  531. def verify_smoketest(headless):
    532. 

  532.     logger.info("Testing ...")
    533. 

  533. 

  534.     s = platform.system()
    535. 

  535.     p = platform_info()
    536. 

  536.     pck = p[1]
    537. 

  537.     arc = p[2]
    538. 

  538. 

  539.     lo_testable_paths = filter(lambda p: \
    540. 

  540.                                os.path.exists(p + os.sep + "program" + os.sep + LOSMOKETEST_BIN) and \
    541. 

  541.                                os.path.exists(p + os.sep + "program" + os.sep + SOFFICE_BIN), \
    542. 

  542.                                lo_all_paths)
    543. 

  543. 

  544.     if not lo_testable_paths:
    545. 

  545.         logger.error("Not found any Libreoffice or Test packages!")
    546. 

  546.         sys.exit(1)
    547. 

  547.     else:
    548. 

  548.         cmd_smoketests = [ p + os.sep + "program" + os.sep + LOSMOKETEST_BIN for p in lo_testable_paths ]
    549. 

  549. 

  550.     if len(lo_testable_paths) > 1:
    551. 

  551.         logger.info("++More than one testable build is found, test them one by one.")
    552. 

  552. 

  553.     # subprocess.call(cmd_smoketest);
    554. 

  554.     for c in cmd_smoketests:
    555. 

  555.         pattern = re.compile(LOSMOKETEST_BIN + "$")
    556. 

  556.         logger.info("  Test Binary: " + pattern.sub(SOFFICE_BIN, c))
    557. 

  557.         subprocess.call(c)
    558. 

  558. 

  559. def usage():
    560. 

  560. 

  561.     print "\n[Usage]\n\n  -f Force testing without asking \n\
    562. 

  562.   -t Testing type pre-release/daily \n\
    563. 

  563.   -l Download and test last builds in a loop \n\
    564. 

  564.   -v Run smoketest verification directly \n\
    565. 

  565.   -s Use the headless mode when running the tests \n\
    566. 

  566.   -i Install the latest build in the DOWNLOAD directory \n\
    567. 

  567.   -u Uninstall any existed libreoffice build \n\
    568. 

  568.   -d Download the latest build for the given test type \n\
    569. 

  569. "
    570. 

    571. 

  571. def main():
    572. 

  572. 

  573.     interactive = True
    574. 

  574.     build_type = "pre-releases"
    575. 

  575. 

  576.     package_type = platform_info()[1]
    577. 

  577.     arch_type = platform_info()[2]
    578. 

  578. 

  579.     loop = False
    580. 

  580.     interactive = True
    581. 

  581.     headless = False
    582. 

  582.     build_type = "pre-releases"
    583. 

  583. 

  584.     # Handling options and arguments
    585. 

  585.     try:
    586. 

  586.         opts, args = getopt.getopt(sys.argv[1:], "dluihfvst:", ["download", "loop", "uninstall", "install", "help", "force", "verify", "headless", "type="])
    587. 

  587.     except getopt.GetoptError, err:
    588. 

  588.         logger.error(str(err))
    589. 

  589.         usage()
    590. 

  590.         sys.exit(2)
    591. 

  591. 

  592.     for o, a in opts:
    593. 

  593.         if ("-t" in o) or ("--type" in o):
    594. 

  594.             build_type = a
    595. 

  595.         elif o in ("-s", "--headless"):
    596. 

  596.             headless = True
    597. 

  597. 

  598.     url_reg = get_url_regexp(build_type, package_type, arch_type)
    599. 

  599. 

  600.     for o, a in opts:
    601. 

  601.         if o in ("-f", "--force"):
    602. 

  602.             interactive = False
    603. 

  603.         elif o in ("-t", "--type"):
    604. 

  604.             pass
    605. 

  605.         elif o in ("-s", "--headless"):
    606. 

  606.             pass
    607. 

  607.         elif o in ("-h", "--help"):
    608. 

  608.             usage()
    609. 

  609.             sys.exit()
    610. 

  610.         elif o in ("-v", "--verify"):
    611. 

  611.             init_testing()
    612. 

  612.             verify_smoketest(headless)
    613. 

  613.             sys.exit()
    614. 

  614.         elif o in ("-i", "--install"):
    615. 

  615.             init_testing()
    616. 

  616.             uninstall(build_type)
    617. 

  617.             install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[0])
    618. 

  618.             install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[2])
    619. 

  619.             sys.exit()
    620. 

  620.         elif o in ("-u", "--uninstall"):
    621. 

  621.             uninstall(build_type)
    622. 

  622.             sys.exit()
    623. 

  623.         elif o in ("-d", "--download"):
    624. 

  624.             init_testing()
    625. 

  625.             download(url_reg, build_type)
    626. 

  626.             sys.exit()
    627. 

  627.         elif o in ("-l", "--loop"):
    628. 

  628.             loop = True
    629. 

  629.         else:
    630. 

  630.             assert False, "Unhandled option: " + o
    631. 

  631. 

  632.     if interactive == True:
    633. 

  633.         key = raw_input("The testing will OVERRIDE existed libreoffice, continue(y/N)? ")
    634. 

  634.         if not (key == "y" or key == "Y" or key == "yes"):
    635. 

  635.             sys.exit()
    636. 

  636. 

  637.     init_testing()
    638. 

  638.     first_run = True
    639. 

  639.     while loop or first_run:
    640. 

  640.         if download(url_reg, build_type):
    641. 

  641.             try:
    642. 

  642.                 # FIXME: uninstall script fails but it need not break the whole game; so try it twice
    643. 

  643.                 try:
    644. 

  644.                     uninstall(build_type)
    645. 

  645.                 except:
    646. 

  646.                     logger.error("Some errors happened during uninstall. Trying once again.")
    647. 

  647.                     uninstall(build_type)
    648. 

  648. 

  649.                 install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[0])
    650. 

  650.                 install(DOWNLOAD_DIR + os.sep + local_build_info(build_type)[2])
    651. 

  651.                 verify_smoketest(headless)
    652. 

  652. 

  653.             except KeyboardInterrupt:
    654. 

  654.                 sys.exit()
    655. 

  655.             except:
    656. 

  656.                 continue
    657. 

  657.         else:
    658. 

  658.              logger.warning("No new build found.")
    659. 

  659.         if loop:
    660. 

  660.             time.sleep(build_check_interval)
    661. 

  661. 

  662.         first_run = False
    663. 

  663. 

  664. 

  665. if __name__ == '__main__':
    666. 

  666. 

  667.     # logging
    668. 

  668.     logger = logging.getLogger('')
    669. 

  669.     logger.setLevel(logging.DEBUG)
    670. 

  670. 

  671.     fh = logging.FileHandler(os.path.basename(__file__) + '.log')
    672. 

  672.     ch = logging.StreamHandler()
    673. 

  673. 

  674.     formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    675. 

  675.     ch.setFormatter(formatter)
    676. 

  676.     fh.setFormatter(formatter)
    677. 

  677. 

  678.     logger.addHandler(ch)
    679. 

  679.     logger.addHandler(fh)
    680. 

  680. 

  681.     main()
    682. 

  682.