kamp/fdroidserver
1
0
Fork 0
mirror of https://gitlab.com/fdroid/fdroidserver.git synced 2024-11-04 22:40:12 +01:00
Code Activity
a3d32c65a4
fdroidserver/makebuildserver

460 lines
22 KiB
Plaintext
Raw Normal View History

Switch all headers to python3
2016-01-04 16:33:20 +01:00
#!/usr/bin/env python3
Better build server creation script
2012-09-24 15:04:58 +02:00
import os
buildserver: use py3's pathlib to generate cache file URL This should handle edge cases better, like odd characters in the path, etc.
2016-09-26 13:17:31 +02:00
import pathlib
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
import requests
buildserver: make sure cachedir is accessible to VM instance It seems that KVM/QEMU's 9p sharing is more sensitive to file perms. If ~/.cache is 0700, then ~/.cache/fdroidserver cannot be mounted in the guest
2016-09-06 14:22:29 +02:00
import stat
Better build server creation script
2012-09-24 15:04:58 +02:00
import sys
import subprocess
import time
Check sha256 sums via hashlib
2014-01-10 19:54:53 +01:00
import hashlib
buildserver: send config to vagrant via YAML file Python can easily output dicts as YAML, and a Vagrantfile is a ruby script, which can easily read YAML. Going this route means that Vagrantfile can ultimately be committed to git, and the configuration will happen all via Python dicts output as YAML. That makes it drastically easier to follow the code, and to make modifications.
2016-07-04 20:22:00 +02:00
import yaml
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
from clint.textui import progress
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
from optparse import OptionParser
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
A few more PEP8 fixes
2014-05-07 16:13:22 +02:00
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
def vagrant(params, cwd=None, printout=False):
"""Run vagrant.
:param: list of parameters to pass to vagrant
:cwd: directory to run in, or None for current directory
:printout: True to print output in realtime, False to just
return it
:returns: (ret, out) where ret is the return code, and out
is the stdout (and stderr) from vagrant
"""
Better build server creation script
2012-09-24 15:04:58 +02:00
p = subprocess.Popen(['vagrant'] + params, cwd=cwd,
always parse versions as strings, not bytes Fixes a couple errors like: File "./makebuildserver", line 30, in vagrant out += line TypeError: Can't convert 'bytes' object to str implicitly If universal_newlines=False, the default, then Popen will return bytes if the newlines in the data do not match the system's newlines. Setting it to true enables auto-conversion, and then guarantees that the data is always str. "If universal_newlines is True, the file objects stdin, stdout and stderr are opened as text streams in universal newlines mode, as described above in Frequently Used Arguments, otherwise they are opened as binary streams." https://docs.python.org/3/library/subprocess.html#subprocess.Popen
2016-03-14 11:05:06 +01:00
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
universal_newlines=True)
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
out = ''
if printout:
while True:
line = p.stdout.readline()
if len(line) == 0:
break
Remove extra blank lines in makebuildserver output These seem to have appeared during the py3 conversion.
2016-03-21 09:45:42 +01:00
print(line.rstrip())
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
out += line
p.wait()
else:
out = p.communicate()[0]
return (p.returncode, out)
Better build server creation script
2012-09-24 15:04:58 +02:00
boxfile = 'buildserver.box'
serverdir = 'buildserver'
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
parser = OptionParser()
parser.add_option("-v", "--verbose", action="store_true", default=False,
A few more PEP8 fixes
2014-05-07 16:13:22 +02:00
help="Spew out even more information than normal")
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
parser.add_option("-c", "--clean", action="store_true", default=False,
A few more PEP8 fixes
2014-05-07 16:13:22 +02:00
help="Build from scratch, rather than attempting to update the existing server")
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
options, args = parser.parse_args()
makebuildserver: set defaults in script so it can run without config This makes it so that ./makebuildserver will run without any config file, using the defaults that are embedded in the script itself. This is like how `fdroid` works.
2016-01-20 21:00:16 +01:00
# set up default config
makebuildserver: use jessie32.box from cache, if present
2016-01-22 13:33:14 +01:00
cachedir = os.path.join(os.getenv('HOME'), '.cache', 'fdroidserver')
makebuildserver: set defaults in script so it can run without config This makes it so that ./makebuildserver will run without any config file, using the defaults that are embedded in the script itself. This is like how `fdroid` works.
2016-01-20 21:00:16 +01:00
config = {
switch to new 64-bit base box image: https://f-droid.org/jessie64.box build-tools and other SDK bits from android-24 require 64-bit GNU/Linux
2016-07-04 12:34:00 +02:00
'basebox': 'jessie64',
makebuildserver: use jessie32.box from cache, if present
2016-01-22 13:33:14 +01:00
'baseboxurl': [
buildserver: use py3's pathlib to generate cache file URL This should handle edge cases better, like odd characters in the path, etc.
2016-09-26 13:17:31 +02:00
pathlib.Path(os.path.join(cachedir, 'jessie64.box')).as_uri(),
switch to new 64-bit base box image: https://f-droid.org/jessie64.box build-tools and other SDK bits from android-24 require 64-bit GNU/Linux
2016-07-04 12:34:00 +02:00
'https://f-droid.org/jessie64.box',
makebuildserver: use jessie32.box from cache, if present
2016-01-22 13:33:14 +01:00
],
makebuildserver: explicitly set debian_mirror by default There needs to be a default, otherwise it crashes. I should have included this in 8d66742dd7feec77aa30382bfb38da83f2b3e5a4
2016-01-26 13:33:53 +01:00
'debian_mirror': 'http://http.debian.net/debian/',
allow setting up an apt package cache for the build server setup This creates a cache folder which will store the apt cache from the VM.
2016-01-26 11:21:21 +01:00
'apt_package_cache': False,
makebuildserver: settable vm boot timeout, plus longer default On slow machines or VMs like the Debian jenkins box, the VM boot timeout needs to be a lot longer, otherwise vagrant times out before setting up the VM.
2016-01-26 17:35:25 +01:00
'boot_timeout': 600,
makebuildserver: use jessie32.box from cache, if present
2016-01-22 13:33:14 +01:00
'cachedir': cachedir,
makebuildserver: set defaults in script so it can run without config This makes it so that ./makebuildserver will run without any config file, using the defaults that are embedded in the script itself. This is like how `fdroid` works.
2016-01-20 21:00:16 +01:00
'cpus': 1,
makebuildserver: default memory to 1024MB, so it runs on normal machines 4 gigs is still a common amount of RAM these days for laptops, if the VM takes almost all of that, it makes the machine drag to almost a halt. Most apps build fine in 1gig of RAM, indeed that's the default for most CI instances, like travis-ci and gitlab-ci.
2016-01-28 13:00:18 +01:00
'memory': 1024,
buildserver: send config to vagrant via YAML file Python can easily output dicts as YAML, and a Vagrantfile is a ruby script, which can easily read YAML. Going this route means that Vagrantfile can ultimately be committed to git, and the configuration will happen all via Python dicts output as YAML. That makes it drastically easier to follow the code, and to make modifications.
2016-07-04 20:22:00 +02:00
'hwvirtex': 'off',
buildserver: auto-detect and use libvirt's QEMU+KVM For running in QEMU/KVM guests like on jenkins.debian.net, this sets up the whole process automatically. This only really covers the case where this is running in a KVM guest, and the original case of running VirtualBox on bare metal. It could be extended to cover more cases if someone wanted to.
2016-09-15 11:12:18 +02:00
'vm_provider': 'virtualbox',
makebuildserver: set defaults in script so it can run without config This makes it so that ./makebuildserver will run without any config file, using the defaults that are embedded in the script itself. This is like how `fdroid` works.
2016-01-20 21:00:16 +01:00
}
name makebuildserver config the same as the script This keeps the numbers of names down to a minimum, and since the config is placed right next to the script, this keeps tab completion working nicely when the config file is in place. The old file name is still supported.
2016-01-20 20:38:18 +01:00
buildserver: auto-detect and use libvirt's QEMU+KVM For running in QEMU/KVM guests like on jenkins.debian.net, this sets up the whole process automatically. This only really covers the case where this is running in a KVM guest, and the original case of running VirtualBox on bare metal. It could be extended to cover more cases if someone wanted to.
2016-09-15 11:12:18 +02:00
if os.path.isfile('/usr/bin/systemd-detect-virt'):
try:
virt = subprocess.check_output('/usr/bin/systemd-detect-virt').strip().decode('utf-8')
except subprocess.CalledProcessError as e:
virt = 'none'
buildserver: bochs can also be used with KVM jenkins.debian.net is being detected as 'bochs' rather than 'qemu'.
2016-09-23 17:40:23 +02:00
if virt == 'qemu' or virt == 'kvm' or virt == 'bochs':
buildserver: auto-detect and use libvirt's QEMU+KVM For running in QEMU/KVM guests like on jenkins.debian.net, this sets up the whole process automatically. This only really covers the case where this is running in a KVM guest, and the original case of running VirtualBox on bare metal. It could be extended to cover more cases if someone wanted to.
2016-09-15 11:12:18 +02:00
print('Running in a VM guest, defaulting to QEMU/KVM via libvirt')
config['vm_provider'] = 'libvirt'
elif virt != 'none':
print('Running in an unsupported VM guest (' + virt + ')!')
name makebuildserver config the same as the script This keeps the numbers of names down to a minimum, and since the config is placed right next to the script, this keeps tab completion working nicely when the config file is in place. The old file name is still supported.
2016-01-20 20:38:18 +01:00
# load config file, if present
if os.path.exists('makebuildserver.config.py'):
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
exec(compile(open('makebuildserver.config.py').read(), 'makebuildserver.config.py', 'exec'), config)
name makebuildserver config the same as the script This keeps the numbers of names down to a minimum, and since the config is placed right next to the script, this keeps tab completion working nicely when the config file is in place. The old file name is still supported.
2016-01-20 20:38:18 +01:00
elif os.path.exists('makebs.config.py'):
# this is the old name for the config file
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
exec(compile(open('makebs.config.py').read(), 'makebs.config.py', 'exec'), config)
makebs: fix config crash Without this, running makebuildserver from a clean master results in the following: $ ./makebuildserver Traceback (most recent call last): File "./makebuildserver", line 74, in <module> del(config['__builtins__']) # added by compile/exec KeyError: '__builtins__' This is because a clean checkout has no config, thus exec is never actually ran.
2016-07-27 11:20:17 +02:00
if '__builtins__' in config:
del(config['__builtins__']) # added by compile/exec
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
Fix makebuildserver after rename, tidy gitignores
2013-12-30 17:18:45 +01:00
if not os.path.exists('makebuildserver') or not os.path.exists(serverdir):
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print('This must be run from the correct directory!')
Better build server creation script
2012-09-24 15:04:58 +02:00
sys.exit(1)
if os.path.exists(boxfile):
os.remove(boxfile)
Add some makebuildserver options
2013-10-20 22:16:42 +02:00
if options.clean:
vagrant(['destroy', '-f'], cwd=serverdir, printout=options.verbose)
buildserver: wipe snapshot from libvirt store on --clean
2016-09-19 16:45:06 +02:00
if config['vm_provider'] == 'libvirt':
subprocess.call(['virsh', 'undefine', 'buildserver_default'])
subprocess.call(['virsh', 'vol-delete', '/var/lib/libvirt/images/buildserver_default.img'])
Cache main sdk/ndk downloads
2013-05-25 14:55:16 +02:00
# Update cached files.
makebuildserver: cache defaults to ~/.cache/fdroidserver This also provides a config option to override that default. ~/.cache is a standard location on GNU/Linux machines for cached content. It is also good to have the cache outside of the git repo in case `git clean -fdx` is run, which would delete all files in the directory that are not part of the git repo, including buildserver/cache/
2016-01-21 14:09:12 +01:00
cachedir = config['cachedir']
Cache main sdk/ndk downloads
2013-05-25 14:55:16 +02:00
if not os.path.exists(cachedir):
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
os.makedirs(cachedir, 0o755)
Fix pep8 warnings in makebuildserver
2014-05-31 23:00:27 +02:00
buildserver: only check cache permissions when using libvirt VirtualBox runs as the same user as `fdroid`, so the cache does not need to be accessible by the world. On libvirt, libvirtd runs the VMs as its own user, so in that case, the cache dirs must have permissions to let that user access them.
2016-09-23 15:19:15 +02:00
if config['vm_provider'] == 'libvirt':
tmp = cachedir
while tmp != '/':
mode = os.stat(tmp).st_mode
if not (stat.S_IXUSR & mode and stat.S_IXGRP & mode and stat.S_IXOTH & mode):
print('ERROR:', tmp, 'will not be accessible to the VM! To fix, run:')
print(' chmod a+X', tmp)
sys.exit(1)
tmp = os.path.dirname(tmp)
buildserver: make sure cachedir is accessible to VM instance It seems that KVM/QEMU's 9p sharing is more sensitive to file perms. If ~/.cache is 0700, then ~/.cache/fdroidserver cannot be mounted in the guest
2016-09-06 14:22:29 +02:00
buildserver: send config to vagrant via YAML file Python can easily output dicts as YAML, and a Vagrantfile is a ruby script, which can easily read YAML. Going this route means that Vagrantfile can ultimately be committed to git, and the configuration will happen all via Python dicts output as YAML. That makes it drastically easier to follow the code, and to make modifications.
2016-07-04 20:22:00 +02:00
if config['apt_package_cache']:
config['aptcachedir'] = cachedir + '/apt/archives'
Cache main sdk/ndk downloads
2013-05-25 14:55:16 +02:00
cachefiles = [
makebs: bump tools to 25.2.2
2016-09-15 21:07:16 +02:00
('https://dl.google.com/android/repository/tools_r25.2.2-linux.zip',
'10d5185af8fee80a7ee093585bf84962d0a877b92a8fef489e2030e910f6a360'),
makebs: bump support repo to 38
2016-09-15 21:07:25 +02:00
('https://dl.google.com/android/repository/android_m2repository_r38.zip',
'69660df7b98764065242bf283807c06aff42ff689eac561fa6e8f249af60201f'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-1.5_r04-linux.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'85b6c8f9797e56aa415d3a282428bb640c96b0acb17c11d41621bb2a5302fe64'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-1.6_r03-linux.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'a8c4e3b32269c6b04c2adeabd112fce42f292dab1a40ef3b08ea7d4212be0df4'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-2.0_r01-linux.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'e70e2151b49613f23f40828c771ab85e241eed361cab037c6312df77f2612f0a'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-2.0.1_r01-linux.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'f47b46177b17f6368461f85bc2a27d0d2c437929f588ea27105712bc3185f664'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-2.1_r03.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'b9cc140a9b879586181b22cfc7d4aa18b979251e16e9b17771c5d0acb71ba940'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-2.2_r03.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'7c9ea1bd7cb225504bd085d7c93ae27d52bd88d29b621d28108f82fef68177c0'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-2.3.1_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'b2ab4896d0a4857e4f688f69eb08b0e1a8074709d4445a92a83ece7ec7cd198c'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-2.3.3_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'54bdb0f1ca06ba5747061ddeea20f431af72c448334fd4d3d7f84ea2ccd29fea'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-3.0_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'1cacae7b6e1b5a5d73c06f5d29d2ea92d16674df8fd5507681290e77d1647a1c'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-3.1_r03.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'7570c86a86488a146aa2141a65a24d81800959c1907ff4f1d2c13bbafab230c5'),
buildserver: use `android update sdk` to install Android SDK `android update sdk --no-ui` is the standard command line tool for installing the Android SDK. By symlinking into the $ANDROID_HOME/temp dir, the cached files can still be used. This converts the chef recipe to a vagrant shell provisioning script since it was all bash anyway. Some file names no longer officially have a -linux in them, so those were changed to keep the cache working with the default filename.
2016-06-14 16:34:13 +02:00
('https://dl.google.com/android/repository/android-3.2_r01.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'ff6b26ad34d7060a72ba504b0314cef8ba3138005561705adec5ad470a073d9b'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-14_r04.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'da1af15c77ba41d062eb6d0ef5921cc424ab6167587033b830609d65f04802b6'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-15_r05.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'5bc1f93aae86b4336ffc4cae9eb8ec41a9a8fd677582dd86a9629798f019bed9'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-16_r05.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'fd7f269a423d1f1d079eabf9f918ceab49108702a1c6bb2589d57c23393503d3'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-17_r03.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'b66e73fb2639f8c916fde4369aa29012a5c531e156dbb205fe3788fe998fbbe8'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-18_r03.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'166ae9cf299747a5faa8f04168f0ee47cd7466a975d8b44acaaa62a43e767568'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-19_r04.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'5efc3a3a682c1d49128daddb6716c433edf16e63349f32959b6207524ac04039'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-20_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'ef08c453e16ab6e656cf5d9413ef61cb8c650607d33b24ee4ce08dafdfe965a7'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-21_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'a76cd7ad3080ac6ce9f037cb935b399a1bad396c0605d4ff42f693695f1dcefe'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/android-22_r02.zip',
Download platforms via makebuildserver
2015-11-20 15:43:47 +01:00
'45eb581bbe53c9256f34c26b2cea919543c0079140897ac721cf88c0b9f6789e'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/platform-23_r03.zip',
Bump platform-23 to r03
2016-05-26 17:05:39 +02:00
'4b4bcddead3319708275c54c76294707bfaa953d767e34f1a5b599f3edd0076c'),
update to platform-24_r02 in ./makebuildserver
2016-08-30 19:47:37 +02:00
('https://dl.google.com/android/repository/platform-24_r02.zip',
'f268f5945c6ece7ea95c1c252067280854d2a20da924e22ae4720287df8bdbc9'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r17-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'4c8444972343a19045236f6924bd7f12046287c70dace96ab88b2159c8ec0e74'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r18.0.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'a9b7b1bdfd864780fdd03fa1683f3fe712a4276cf200646833808cb9159bafc0'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r18.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'0753606738f31cc346426db1d46b7d021bc1bdaff63085f9ee9d278ee054d3c9'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r18.1.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'7e4ed326b53078f4f23276ddab52c400011f7593dfbb6508c0a6671954dba8b0'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r19-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'9442e1c5212ed594e344a231fa93e7a017a5ef8cc661117011f1d3142eca7acc'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r19.0.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'b068edaff05c3253a63e9c8f0e1786429799b7e4b01514a847a8b291beb9232e'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r19.0.2-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'06124fad0d4bde21191240d61df2059a8546c085064a9a57d024c36fa2c9bebb'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r19.0.3-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'bc9b3db0de4a3e233a170274293359051a758f1e3f0d0d852ff4ad6d90d0a794'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r19.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'3833b409f78c002a83244e220be380ea6fa44d604e0d47de4b7e5daefe7cd3f4'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r20-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'296e09d62095d80e6eaa06a64cfa4c6f9f317c2d67ad8da6514523ec66f5c871'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'12b818f38fe1b68091b94545988317438efbf41eb61fd36b72cd79f536044065'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21.0.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'a8922e80d3dd0cf6df14b29a7862448fa111b48086c639168d4b18c92431f559'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21.0.2-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'859b17a6b65d063dfd86c163489b736b12bdeecd9173fdddb3e9f32e0fe584b7'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'022a85b92360272379b2f04b8a4d727e754dbe7eb8ab5a9568190e33e480d8f1'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21.1.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'29b612484de6b5cde0df6de655e413f7611b0557b440538397afa69b557e2f08'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r21.1.2-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'3f88efc2d5316fb73f547f35b472610eed5e6f3f56762750ddad1c7d1d81660d'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r22-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'061c021243f04c80c19568a6e3a027c00d8e269c9311d7bf07fced60fbde7bd5'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r22.0.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'91e5524bf227aad1135ddd10905518ac49f74797d33d48920dcf8364b9fde214'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r23-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'56bf4fc6c43638c55fef4a0937bad38281945725459841879b436c6922df786c'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r23.0.1-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'e56b3ef7b760ad06a7cee9b2d52ba7f43133dcecedfa5357f8845b3a80aeeecf'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r23.0.2-linux.zip',
Install build-tools from the cache too
2015-11-20 21:14:08 +01:00
'82754f551a6e36eaf516fbdd00c95ff0ccd19f81d1e134125b6ac4916f7ed9b6'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://dl.google.com/android/repository/build-tools_r23.0.3-linux.zip',
Add and switch to build-tools 23.0.3 Also bump to the CI image which contains it.
2016-04-05 11:49:30 +02:00
'd961663d4a9e128841751c0156548a347c882c081c83942e53788d8949bf34e1'),
all: add and switch to build-tools v24
2016-06-24 17:54:30 +02:00
('https://dl.google.com/android/repository/build-tools_r24-linux.zip',
'b4871f357224c5f660fd2bbee04d8c7d1c187eeddfd9702cc84503529e3b3724'),
makebs: add build-tools-24.0.1 Fixes #196.
2016-07-25 12:40:44 +02:00
('https://dl.google.com/android/repository/build-tools_r24.0.1-linux.zip',
new build-tools_r24.0.1.zip sha256, Google keeps changing it I validated this versus the Google repository XML downloaded from two separate paths from: https://dl.google.com/android/repository/repository-12.xml Using their SHA1: 84f18c392919a074fcbb9b1d967984e6b2fef8b4
2016-08-30 18:19:34 +02:00
'a38ac637db357a31e33e38248399cb0edcc15040dca041370da38b6daf50c84d'),
add build-tools_r24.0.2-linux.zip to ./makebuildserver
2016-08-30 18:19:49 +02:00
('https://dl.google.com/android/repository/build-tools_r24.0.2-linux.zip',
'924e29b8a189afbd119d44eae450fc0c9f197ed6f835df223931e45007987d95'),
name makebuildserver config the same as the script This keeps the numbers of names down to a minimum, and since the config is placed right next to the script, this keeps tab completion working nicely when the config file is in place. The old file name is still supported.
2016-01-20 20:38:18 +01:00
# the binaries that Google uses are here:
# https://android.googlesource.com/platform/tools/external/gradle/+/studio-1.5/
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.4-bin.zip',
Install gradle version 1.4, 1.6, 1.7, 1.8 and 1.9 to /opt/gradle
2014-01-09 15:44:58 +01:00
'cd99e85fbcd0ae8b99e81c9992a2f10cceb7b5f009c3720ef3a0078f4f92e94e'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.6-bin.zip',
Install gradle version 1.4, 1.6, 1.7, 1.8 and 1.9 to /opt/gradle
2014-01-09 15:44:58 +01:00
'de3e89d2113923dcc2e0def62d69be0947ceac910abd38b75ec333230183fac4'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.7-bin.zip',
Install gradle version 1.4, 1.6, 1.7, 1.8 and 1.9 to /opt/gradle
2014-01-09 15:44:58 +01:00
'360c97d51621b5a1ecf66748c718594e5f790ae4fbc1499543e0c006033c9d30'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.8-bin.zip',
Install gradle version 1.4, 1.6, 1.7, 1.8 and 1.9 to /opt/gradle
2014-01-09 15:44:58 +01:00
'a342bbfa15fd18e2482287da4959588f45a41b60910970a16e6d97959aea5703'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.9-bin.zip',
Update to gradle 1.9
2013-12-22 13:22:45 +01:00
'097ddc2bcbc9da2bb08cbf6bf8079585e35ad088bafd42e8716bc96405db98e9'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.10-bin.zip',
Add gradle 1.10 with the new plugin 0.8 release
2014-01-27 13:21:44 +01:00
'6e6db4fc595f27ceda059d23693b6f6848583950606112b37dfd0e97a0a0a4fe'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.11-bin.zip',
Add support for gradle 1.11 (and plugin ver 0.9)
2014-03-07 15:21:18 +01:00
'07e235df824964f0e19e73ea2327ce345c44bcd06d44a0123d29ab287fc34091'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-1.12-bin.zip',
Add gradle 1.12 for the plugin version 0.10 Also, use https for the gradle.org links
2014-05-20 16:40:43 +02:00
'8734b13a401f4311ee418173ed6ca8662d2b0a535be8ff2a43ecb1c13cd406ea'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.1-bin.zip',
Add support for gradle plugin version 0.13 via gradle 2.1
2014-10-07 16:36:10 +02:00
'3eee4f9ea2ab0221b89f8e4747a96d4554d00ae46d8d633f11cfda60988bf878'),
Add Gradle 2.2 and 2.14 to the buildserver 2.2 can be specifically requested by an app, and in some extreme cases those apps don't build with 2.2.1.
2016-06-24 18:03:48 +02:00
('https://services.gradle.org/distributions/gradle-2.2-bin.zip',
'91e5655fe11ef414449f218c4fa2985b3a49b7903c57556da109c84fa26e1dfb'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.2.1-bin.zip',
Add gradle 2.2.1 for plugin versions 1.0.X
2014-12-12 12:29:16 +01:00
'420aa50738299327b611c10b8304b749e8d3a579407ee9e755b15921d95ff418'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.3-bin.zip',
Add gradle 2.3 to the buildserver Fixes apps that explicitly require 2.3 via gradleVersion
2015-04-09 16:02:35 +02:00
'010dd9f31849abc3d5644e282943b1c1c355f8e2635c5789833979ce590a3774'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.4-bin.zip',
Add gradle 2.4
2015-06-18 16:57:00 +02:00
'c4eaecc621a81f567ded1aede4a5ddb281cc02a03a6a87c4f5502add8fc2f16f'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.5-bin.zip',
Add gradle 2.5, fixes #108
2015-08-13 20:28:01 +02:00
'3f953e0cb14bb3f9ebbe11946e84071547bf5dfd575d90cfe9cc4e788da38555'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.6-bin.zip',
Add gradle 2.6 to the buildserver
2015-08-18 22:40:21 +02:00
'18a98c560af231dfa0d3f8e0802c20103ae986f12428bb0a6f5396e8f14e9c83'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.7-bin.zip',
Fix shasum for gradle 2.7 (see a229afe1)
2015-10-08 15:16:16 +02:00
'cde43b90945b5304c43ee36e58aab4cc6fb3a3d5f9bd9449bb1709a68371cb06'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.8-bin.zip',
Fix gradle-2.8 checksum I once again did the -all.zip hash, not the -bin.zip one.
2015-10-25 10:48:17 +01:00
'a88db9c2f104defdaa8011c58cf6cda6c114298ae3695ecfb8beb30da3a903cb'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.9-bin.zip',
Add gradle 2.9 to the BS
2015-11-20 21:24:07 +01:00
'c9159ec4362284c0a38d73237e224deae6139cbde0db4f0f44e1c7691dd3de2f'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.10-bin.zip',
Add Gradle 2.10 to the BS
2016-01-05 09:15:54 +01:00
'66406247f745fc6f05ab382d3f8d3e120c339f34ef54b86f6dc5f6efc18fbb13'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.11-bin.zip',
Add gradle 2.11
2016-02-15 12:44:07 +01:00
'8d7437082356c9fd6309a4479c8db307673965546daea445c6c72759cd6b1ed6'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.12-bin.zip',
Add Gradle 2.12 to the buildserver
2016-04-05 11:49:15 +02:00
'e77064981906cd0476ff1e0de3e6fef747bd18e140960f1915cca8ff6c33ab5c'),
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
('https://services.gradle.org/distributions/gradle-2.13-bin.zip',
Add gradle 2.13
2016-05-26 16:45:54 +02:00
'0f665ec6a5a67865faf7ba0d825afb19c26705ea0597cec80dd191b0f2cbb664'),
Add Gradle 2.2 and 2.14 to the buildserver 2.2 can be specifically requested by an app, and in some extreme cases those apps don't build with 2.2.1.
2016-06-24 18:03:48 +02:00
('https://services.gradle.org/distributions/gradle-2.14-bin.zip',
'993b4f33b652c689e9721917d8e021cab6bbd3eae81b39ab2fd46fdb19a928d5'),
Add gradle 2.14.1
2016-08-12 19:52:32 +02:00
('https://services.gradle.org/distributions/gradle-2.14.1-bin.zip',
'cfc61eda71f2d12a572822644ce13d2919407595c2aec3e3566d2aab6f97ef39'),
makebs: add gradle 3.0
2016-08-18 17:53:27 +02:00
('https://services.gradle.org/distributions/gradle-3.0-bin.zip',
'39c906941a474444afbddc38144ed44166825acb0a57b0551dddb04bbf157f80'),
makebs: add gradle 3.1
2016-09-23 07:50:52 +02:00
('https://services.gradle.org/distributions/gradle-3.1-bin.zip',
'c7de3442432253525902f7e8d7eac8b5fd6ce1623f96d76916af6d0e383010fc'),
buildserver: remove last vestige of 32-bit buildserver
2016-07-04 17:14:06 +02:00
('https://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin',
'102d6723f67ff1384330d12c45854315d6452d6510286f4e5891e00a5a8f1d5a'),
('https://dl.google.com/android/ndk/android-ndk-r9b-linux-x86_64.tar.bz2',
'8956e9efeea95f49425ded8bb697013b66e162b064b0f66b5c75628f76e0f532'),
('https://dl.google.com/android/ndk/android-ndk-r9b-linux-x86_64-legacy-toolchains.tar.bz2',
'de93a394f7c8f3436db44568648f87738a8d09801a52f459dcad3fc047e045a1'),
Add ndk r11c
2016-08-12 20:24:54 +02:00
('https://dl.google.com/android/repository/android-ndk-r11c-linux-x86_64.zip',
'ba85dbe4d370e4de567222f73a3e034d85fc3011b3cbd90697f3e8dcace3ad94'),
Re-add NDK r12b, now fixed.
2016-08-02 11:09:32 +02:00
('https://dl.google.com/android/repository/android-ndk-r12b-linux-x86_64.zip',
'eafae2d614e5475a3bcfd7c5f201db5b963cc1290ee3e8ae791ff0c66757781e'),
Add qt sdk support
2016-09-24 14:10:55 +02:00
('https://download.qt.io/official_releases/qt/5.7/5.7.0/qt-opensource-linux-x64-android-5.7.0.run',
'f7e55b7970e59bdaabb88cb7afc12e9061e933992bda2f076f52600358644586'),
Apply some autopep8-python2 suggestions
2014-12-31 16:42:26 +01:00
]
Fix pep8 warnings in makebuildserver
2014-05-31 23:00:27 +02:00
A few more PEP8 fixes
2014-05-07 16:13:22 +02:00
Check sha256 sums via hashlib
2014-01-10 19:54:53 +01:00
def sha256_for_file(path):
Fix python2/makebuildserver breakage
2016-03-13 21:49:38 +01:00
with open(path, 'rb') as f:
Check sha256 sums via hashlib
2014-01-10 19:54:53 +01:00
s = hashlib.sha256()
while True:
data = f.read(4096)
if not data:
break
s.update(data)
return s.hexdigest()
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
for srcurl, shasum in cachefiles:
filename = os.path.basename(srcurl)
local_filename = os.path.join(cachedir, filename)
if os.path.exists(local_filename):
local_length = os.path.getsize(local_filename)
else:
local_length = -1
resume_header = {}
download = True
try:
r = requests.head(srcurl, allow_redirects=True, timeout=60)
if r.status_code == 200:
content_length = int(r.headers.get('content-length'))
Install gradle 1.7 to buildserver (untested, may need some extra config)
2013-08-09 20:37:13 +02:00
else:
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
content_length = local_length # skip the download
except requests.exceptions.RequestException as e:
content_length = local_length # skip the download
print(e)
Install gradle 1.7 to buildserver (untested, may need some extra config)
2013-08-09 20:37:13 +02:00
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
if local_length == content_length:
download = False
elif local_length > content_length:
print('deleting corrupt file from cache: ' + local_filename)
os.remove(local_filename)
print("Downloading " + filename + " to cache")
elif local_length > -1 and local_length < content_length:
print("Resuming download of " + local_filename)
resume_header = {'Range': 'bytes=%d-%d' % (local_length, content_length)}
else:
print("Downloading " + filename + " to cache")
if download:
r = requests.get(srcurl, headers=resume_header,
stream=True, verify=False, allow_redirects=True)
content_length = int(r.headers.get('content-length'))
with open(local_filename, 'ab') as f:
Tone down makebuildserver terminal spamming The progress bar updating at each 1k chunk spams the terminal to such an extent it stops responding to keypresses (at least with a fast connection). It also seems extremely inefficient to be writing the file in 1k chunks. This makes it 64k, which is more reasonable but quite probably still too small.
2016-06-17 14:39:01 +02:00
for chunk in progress.bar(r.iter_content(chunk_size=65536),
expected_size=(content_length / 65536) + 1):
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
if chunk: # filter out keep-alive new chunks
f.write(chunk)
v = sha256_for_file(local_filename)
if v == shasum:
print("\t...shasum verified for " + local_filename)
else:
print("Invalid shasum of '" + v + "' detected for " + local_filename)
buildserver: delete corrupt files from the cache In order to make CI and other automation easier, delete any corrupt files from the cache if they fail the SHA-256 check. https://jenkins.debian.net/view/reproducible/job/reproducible_setup_fdroid_build_environment_profitbricks3/112/console
2016-07-06 22:16:26 +02:00
os.remove(local_filename)
makebuildserver: use original names for downloaded SDK components It will make it a lot easier to manage the cache if we use the original file names, which often include the file version. This also changes the download process to be resumable if there is a partial file in the cache, and switches from calling wget on the command line to using the python libs 'requests' and 'clint' to provide a similar experience. While its not so important for this particular bit of code to use those libraries, I think those two will allow us to provide a better user experience throughout the whole of fdroidserver. In this case, it is already doing special tricks fetching the file size from the server before trying to download it. I suppose this code could instead check if the file exists, and if so, check the hash sum. I think that would be slower for most people since checking the hash on large files takes a noticeable about of time, while a HTTP HEAD request is pretty tiny.
2016-06-10 11:42:42 +02:00
sys.exit(1)
Cache main sdk/ndk downloads
2013-05-25 14:55:16 +02:00
Add qt sdk support
2016-09-24 14:10:55 +02:00
local_qt_filename = os.path.join(cachedir, 'qt-opensource-linux-x64-android-5.7.0.run')
print("Setting executable bit for " + local_qt_filename)
os.chmod(local_qt_filename, 0o755)
makebuildserver: use VB software virt if hardware is not available This checks the local CPU settings to see if it has the right virtualizing CPU instructions, and only uses VirtualBox hardware virtualization on setups where it is available. VMs instances usually do not provide these instructions. Where the CPU features are not available, it will use VB's software virtualization.
2016-03-10 09:51:20 +01:00
# use VirtualBox software virtualization if hardware is not available,
# like if this is being run in kvm or some other VM platform, like
# http://jenkins.debian.net, the values are 'on' or 'off'
if sys.platform.startswith('darwin'):
# all < 10 year old Macs work, and OSX servers as VM host are very
# rare, but this could also be auto-detected if someone codes it
buildserver: send config to vagrant via YAML file Python can easily output dicts as YAML, and a Vagrantfile is a ruby script, which can easily read YAML. Going this route means that Vagrantfile can ultimately be committed to git, and the configuration will happen all via Python dicts output as YAML. That makes it drastically easier to follow the code, and to make modifications.
2016-07-04 20:22:00 +02:00
config['hwvirtex'] = 'on'
makebuildserver: use VB software virt if hardware is not available This checks the local CPU settings to see if it has the right virtualizing CPU instructions, and only uses VirtualBox hardware virtualization on setups where it is available. VMs instances usually do not provide these instructions. Where the CPU features are not available, it will use VB's software virtualization.
2016-03-10 09:51:20 +01:00
elif os.path.exists('/proc/cpuinfo'):
with open('/proc/cpuinfo') as f:
contents = f.read()
if 'vmx' in contents or 'svm' in contents:
buildserver: send config to vagrant via YAML file Python can easily output dicts as YAML, and a Vagrantfile is a ruby script, which can easily read YAML. Going this route means that Vagrantfile can ultimately be committed to git, and the configuration will happen all via Python dicts output as YAML. That makes it drastically easier to follow the code, and to make modifications.
2016-07-04 20:22:00 +02:00
config['hwvirtex'] = 'on'
buildserver: buildserver/Vagrantfile is configed by .yaml file Vagrantfile is now committed and not changed between configurations. It is configed by translating the python config file's dict to a YAML file, which Vagrantfile now loads and uses. This makes it a lot easier for vagrant users and python programmers to understand, and hopefully makes it easier to maintain and test with.
2016-07-04 20:49:41 +02:00
# Check against the existing Vagrantfile.yaml, and if they differ, we
# need to create a new box:
vf = os.path.join(serverdir, 'Vagrantfile.yaml')
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
writevf = True
if os.path.exists(vf):
buildserver: auto-detect and use libvirt's QEMU+KVM For running in QEMU/KVM guests like on jenkins.debian.net, this sets up the whole process automatically. This only really covers the case where this is running in a KVM guest, and the original case of running VirtualBox on bare metal. It could be extended to cover more cases if someone wanted to.
2016-09-15 11:12:18 +02:00
print('Halting', serverdir)
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
vagrant(['halt'], serverdir)
buildserver: buildserver/Vagrantfile is configed by .yaml file Vagrantfile is now committed and not changed between configurations. It is configed by translating the python config file's dict to a YAML file, which Vagrantfile now loads and uses. This makes it a lot easier for vagrant users and python programmers to understand, and hopefully makes it easier to maintain and test with.
2016-07-04 20:49:41 +02:00
with open(vf, 'r', encoding='utf-8') as f:
oldconfig = yaml.load(f)
if config != oldconfig:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Server configuration has changed, rebuild from scratch is required")
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
vagrant(['destroy', '-f'], serverdir)
else:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Re-provisioning existing server")
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
writevf = False
else:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("No existing server - building from scratch")
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
if writevf:
buildserver: buildserver/Vagrantfile is configed by .yaml file Vagrantfile is now committed and not changed between configurations. It is configed by translating the python config file's dict to a YAML file, which Vagrantfile now loads and uses. This makes it a lot easier for vagrant users and python programmers to understand, and hopefully makes it easier to maintain and test with.
2016-07-04 20:49:41 +02:00
with open(vf, 'w', encoding='utf-8') as f:
yaml.dump(config, f)
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
buildserver: auto-detect and use libvirt's QEMU+KVM For running in QEMU/KVM guests like on jenkins.debian.net, this sets up the whole process automatically. This only really covers the case where this is running in a KVM guest, and the original case of running VirtualBox on bare metal. It could be extended to cover more cases if someone wanted to.
2016-09-15 11:12:18 +02:00
if config['vm_provider'] == 'libvirt':
returncode, out = vagrant(['box', 'list'], serverdir, printout=options.verbose)
found_basebox = False
needs_mutate = False
for line in out.splitlines():
if line.startswith(config['basebox']):
found_basebox = True
if line.split('(')[1].split(',')[0] != 'libvirt':
needs_mutate = True
continue
if not found_basebox:
if isinstance(config['baseboxurl'], str):
baseboxurl = config['baseboxurl']
else:
baseboxurl = config['baseboxurl'][0]
print('Adding', config['basebox'], 'from', baseboxurl)
vagrant(['box', 'add', '--name', config['basebox'], baseboxurl],
serverdir, printout=options.verbose)
needs_mutate = True
if needs_mutate:
print('Converting', config['basebox'], 'to libvirt format')
vagrant(['mutate', config['basebox'], 'libvirt'],
serverdir, printout=options.verbose)
print('Removing virtualbox format copy of', config['basebox'])
vagrant(['box', 'remove', '--provider', 'virtualbox', config['basebox']],
serverdir, printout=options.verbose)
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Configuring build server VM")
Ensure makebuildserver provisions on an update
2015-08-27 12:12:22 +02:00
returncode, out = vagrant(['up', '--provision'], serverdir, printout=True)
Log buildserver setup
2013-02-12 16:20:30 +01:00
with open(os.path.join(serverdir, 'up.log'), 'w') as log:
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
log.write(out)
Build server to r21
2013-01-21 12:09:56 +01:00
if returncode != 0:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Failed to configure server")
Properly stop making build server base image on failure
2013-04-10 10:36:31 +02:00
sys.exit(1)
Write buildserver ID to buildserver on creation The ID of the buildserver is just the corresponding commit hash in fdroidserver at the point where it was built, which should be enough to uniquely identify a version of it. The idea is that this will ultimately end up as metadata in an apk, such that its precise lineage can be traced, and the exact same binary can be reproduced.
2013-11-09 12:51:39 +01:00
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Writing buildserver ID")
makebuildserver: buildserverid should always be a string
2016-03-14 17:33:06 +01:00
p = subprocess.Popen(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE,
universal_newlines=True)
Write buildserver ID to buildserver on creation The ID of the buildserver is just the corresponding commit hash in fdroidserver at the point where it was built, which should be enough to uniquely identify a version of it. The idea is that this will ultimately end up as metadata in an apk, such that its precise lineage can be traced, and the exact same binary can be reproduced.
2013-11-09 12:51:39 +01:00
buildserverid = p.communicate()[0].strip()
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("...ID is " + buildserverid)
Write buildserver ID to buildserver on creation The ID of the buildserver is just the corresponding commit hash in fdroidserver at the point where it was built, which should be enough to uniquely identify a version of it. The idea is that this will ultimately end up as metadata in an apk, such that its precise lineage can be traced, and the exact same binary can be reproduced.
2013-11-09 12:51:39 +01:00
subprocess.call(
['vagrant', 'ssh', '-c', 'sh -c "echo {0} >/home/vagrant/buildserverid"'
Fix pep8 warnings in makebuildserver
2014-05-31 23:00:27 +02:00
.format(buildserverid)],
Write buildserver ID to buildserver on creation The ID of the buildserver is just the corresponding commit hash in fdroidserver at the point where it was built, which should be enough to uniquely identify a version of it. The idea is that this will ultimately end up as metadata in an apk, such that its precise lineage can be traced, and the exact same binary can be reproduced.
2013-11-09 12:51:39 +01:00
cwd=serverdir)
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Stopping build server VM")
Better build server creation script
2012-09-24 15:04:58 +02:00
vagrant(['halt'], serverdir)
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Waiting for build server VM to be finished")
Better build server creation script
2012-09-24 15:04:58 +02:00
ready = False
while not ready:
time.sleep(2)
Much better build server provisioning Including selection of correct ndk architecture, caching and performance improvements, better configurability, etc.
2013-05-31 08:48:39 +02:00
returncode, out = vagrant(['status'], serverdir)
Better build server creation script
2012-09-24 15:04:58 +02:00
if returncode != 0:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Error while checking status")
Better build server creation script
2012-09-24 15:04:58 +02:00
sys.exit(1)
for line in out.splitlines():
if line.startswith("default"):
if line.find("poweroff") != -1:
ready = True
else:
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Status: " + line)
Better build server creation script
2012-09-24 15:04:58 +02:00
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Packaging")
Better makebuildserver verbose output (and always delete box file, its always there, despite my earlier commit saying it wasn't)
2014-01-09 22:31:58 +01:00
vagrant(['package', '--output', os.path.join('..', boxfile)], serverdir,
printout=options.verbose)
Run 2to3 on makebuildserver Mostly just print conversion.
2016-01-04 17:24:57 +01:00
print("Adding box")
Better makebuildserver verbose output (and always delete box file, its always there, despite my earlier commit saying it wasn't)
2014-01-09 22:31:58 +01:00
vagrant(['box', 'add', 'buildserver', boxfile, '-f'],
printout=options.verbose)
Better build server creation script
2012-09-24 15:04:58 +02:00
Better makebuildserver verbose output (and always delete box file, its always there, despite my earlier commit saying it wasn't)
2014-01-09 22:31:58 +01:00
os.remove(boxfile)
Copy Permalink