run-boost-tests

#!/usr/bin/env ruby

# Copyright (c) 2011-2015 CrystaX .NET.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification, are
# permitted provided that the following conditions are met:
#
#    1. Redistributions of source code must retain the above copyright notice, this list of
#       conditions and the following disclaimer.
#
#    2. Redistributions in binary form must reproduce the above copyright notice, this list
#       of conditions and the following disclaimer in the documentation and/or other materials
#       provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY CrystaX .NET ''AS IS'' AND ANY EXPRESS OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
# FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CrystaX .NET OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# The views and conclusions contained in the software and documentation are those of the
# authors and should not be interpreted as representing official policies, either expressed
# or implied, of CrystaX .NET.

require 'optparse'
require 'securerandom'
require 'open3'
require 'pathname'
require_relative 'lib/log'

Encoding.default_external = Encoding::UTF_8
ENV['LANG'] = 'en_US.UTF-8'
ENV['LC_ALL'] = ENV['LANG']

module Enumerable
    def deep_freeze
        unless self.is_a? String
            frozen = self.dup.each do |key, value|
                if (value.is_a?(Enumerable) && !value.is_a?(String))
                    value.deep_freeze
                else
                    value.freeze
                end
            end
            self.replace(frozen)
        end
        self.freeze
    end
end

class Hash
    def deep_freeze
        frozen = self.dup.each do |key, value|
            if (value.is_a?(Enumerable) && !value.is_a?(String))
                value.deep_freeze
            else
                value.freeze
            end
        end
        self.replace(frozen)
        self.freeze
    end
end

OPTIONS = {}
OPTIONS[:testdir] = File.join(ENV['HOME'], '.crystax', 'boost')
OPTIONS[:ndk] = File.expand_path('../..', __FILE__)

optparser = OptionParser.new do |o|
    o.banner = <<-EOF
Test Boost libraries with CrystaX NDK.

This requires a temporary NDK installation containing toolchain binaries for all target architectures.

By default, this will try with the current NDK directory, unless you use the --ndk-dir=<path> option.
    EOF

    o.separator "\nCommon options:\n\n"

    o.on("-h", "--help", "Show help screen and exit") do
        puts optparser
        exit 0
    end

    OPTIONS[:verbose] = false
    o.on("-v", "--[no-]verbose", "Enable verbose mode [#{OPTIONS[:verbose]}]") do |v|
        OPTIONS[:verbose] = v
    end

    begin
        case RUBY_PLATFORM
        when /linux/
            numcpus = File.read("/proc/cpuinfo").split("\n").select { |l| l =~ /^processor\b/ }.size
        when /darwin/
            numcpus = `sysctl -n hw.ncpu`.chomp.to_i
        end
        OPTIONS[:jobs] = numcpus * 2
    rescue
        OPTIONS[:jobs] = 1
    end
    o.on("-jN", "--jobs=N", Integer, "Use specified number of build jobs") do |j|
        OPTIONS[:jobs] = j
    end

    OPTIONS[:log] = ENV['NDK_LOGFILE'] || File.join(OPTIONS[:testdir], 'test.log')
    o.on("-l", "--log=FILE", "Log file [#{OPTIONS[:log]}]") do |l|
        OPTIONS[:log] = File.expand_path(l)
    end

    OPTIONS[:print_timestamps] = true
    o.on("--[no-]print-timestamps", "Print timestamps in log [#{OPTIONS[:print_timestamps]}]") do |p|
        OPTIONS[:print_timestamps] = p
    end

    o.separator "\nRequired parameters:\n\n"

    o.on("--runner=RUNNER", "Explicit runner name") do |r|
        OPTIONS[:runner] = r
    end

    o.separator "\nOptional parameters:\n\n"

    o.on("--ndk-dir=PATH", "Specify NDK root path for the build [#{OPTIONS[:ndk]}]") do |p|
        OPTIONS[:ndk] = File.expand_path(p)
    end

    o.on("--test-dir=PATH", "Specify test directory [#{OPTIONS[:testdir]}]") do |p|
        OPTIONS[:testdir] = File.expand_path(p)
    end

    OPTIONS[:abis] = ['armeabi', 'armeabi-v7a', 'armeabi-v7a-hard', 'x86', 'mips', 'arm64-v8a', 'x86_64', 'mips64']
    o.on("--abis=LIST", Array, "Specify list of target ABIs [#{OPTIONS[:abis].join(',')}]") do |a|
        OPTIONS[:abis] = a
    end

    OPTIONS[:adb] = 'adb'
    o.on("--adb=PATH", "Specify which adb to use [#{OPTIONS[:adb]}]") do |p|
        OPTIONS[:adb] = File.expand_path(p)
    end

    o.on("--libraries=LIST", Array, "Explicit list of libraries to test [all]") do |l|
        OPTIONS[:libraries] = l
    end

    OPTIONS[:device_path] = "/data/local/tmp/boost-#{SecureRandom.uuid}"
    o.on("--device-path=PATH", "Path on device where to push files [#{OPTIONS[:device_path]}]") do |p|
        OPTIONS[:device_path] = p
    end

    OPTIONS[:pie] = true
    o.on("--[no-]pie", "Produce PIE-enabled binaries to test [#{OPTIONS[:pie]}]") do |p|
        OPTIONS[:pie] = false
    end

    OPTIONS[:fetch_sources] = true
    o.on("--skip-fetch-sources", "Skip fetch&update of Boost sources [#{!OPTIONS[:fetch_sources]}]") do
        OPTIONS[:fetch_sources] = false
    end

    OPTIONS[:publish] = false
    o.on("--publish-results", "Publish test results, uploading them to the public FTP [#{OPTIONS[:publish]}]") do
        OPTIONS[:publish] = true
    end

    OPTIONS[:toolchain_versions] = Dir.glob(File.join(OPTIONS[:ndk], 'toolchains', '*')).select do |e|
        File.directory?(e) && File.exists?(File.join(e, 'setup.mk')) && File.exists?(File.join(e, 'config.mk'))
    end.map { |e| File.basename(e) }.reject { |e| e =~ /^llvm\b/ }.map do |e|
        e.sub(/^.*-([^-]+)$/, '\1')
    end.sort.uniq.map { |e| e.sub(/^(\d.*)$/, 'gcc\1') }.select { |e| e =~ /^(gcc|clang)/ }

    o.on("--toolchain-versions=LIST", Array, "Toolchain versions [#{OPTIONS[:toolchain_versions].join(',')}]") do |l|
        OPTIONS[:toolchain_versions] = l
    end

    OPTIONS[:tag] = 'master'
    o.on("--tag=TAG", "Boost tag to test ('master' or 'develop') [#{OPTIONS[:tag]}]") do |t|
        OPTIONS[:tag] = t
    end

    OPTIONS[:timeout] = 15
    o.on("--timeout=VALUE", "Timeout for one separate test in minutes [#{OPTIONS[:timeout]}]") do |t|
        OPTIONS[:timeout] = t
    end

    o.on("--std=STD", "Use specified C++ standard to build tests") do |s|
        OPTIONS[:std] = s
    end

    o.on("--emulator-tag=TAG", "Run tests only on emulators matching specified tag") do |t|
        OPTIONS[:emulator_tag] = t
    end

    o.on("--runner-comment-header=FILE", "Header of runner comment") do |h|
        OPTIONS[:runner_comment_header] = File.expand_path(h)
    end

    o.on("--runner-comment-footer=FILE", "Footer of runner comment") do |f|
        OPTIONS[:runner_comment_footer] = File.expand_path(f)
    end

    OPTIONS[:boost_url] = 'https://github.com/boostorg/boost'
    o.on("--boost-url=URL", "Use alternative git URL for Boost sources [#{OPTIONS[:boost_url]}]") do |u|
        OPTIONS[:boost_url] = u
    end

    OPTIONS[:boost_build_url] = 'https://github.com/boostorg/build.git'
    o.on("--boost-build-url=URL", "Use alternative git URL for Boost.Build sources [#{OPTIONS[:boost_build_url]}]") do |u|
        OPTIONS[:boost_build_url] = u
    end

    OPTIONS[:boost_regression_url] = 'https://github.com/boostorg/regression.git'
    o.on("--boost-regression-url=URL", "Use alternative git URL for Boost.Regression sources [#{OPTIONS[:boost_regression_url]}]") do |u|
        OPTIONS[:boost_regression_url] = u
    end

end
optparser.parse!(ARGV)

if !ARGV.empty?
    $stderr.puts "ERROR: Unknown options: #{ARGV.join(" ")}"
    $stderr.puts ""
    $stderr.puts optparser
    exit 1
end

OPTIONS.deep_freeze

if OPTIONS[:runner].nil?
    $stderr.puts "ERROR: Runner name is not specified"
    $stderr.puts ""
    $stderr.puts optparser
    exit 1
end

case OPTIONS[:tag]
when 'master', 'develop'
    # OK
else
    $stderr.puts "ERROR: Wrong tag value: '#{OPTIONS[:tag]}'"
    exit 1
end

REGRESSION_DIR = File.join(OPTIONS[:testdir], OPTIONS[:tag], 'regression')

BOOST_SRCDIR    = File.join(OPTIONS[:testdir], OPTIONS[:tag], 'src', 'boost')
BOOST_BB_SRCDIR = File.join(OPTIONS[:testdir], OPTIONS[:tag], 'src', 'boost_bb')
BOOST_RR_SRCDIR = File.join(OPTIONS[:testdir], OPTIONS[:tag], 'src', 'boost_rr')

WLOG = "/tmp/wrappers-#{SecureRandom.uuid}.log"
at_exit { FileUtils.rm_f WLOG }
FileUtils.rm_f WLOG
FileUtils.touch WLOG

FileUtils.mkdir_p OPTIONS[:testdir]

Log.timestamps = OPTIONS[:print_timestamps]

Log.add StdLogger.new(OPTIONS[:verbose] ? Log::DEBUG : Log::NOTICE)
Log.add FileLogger.new(OPTIONS[:log], Log::DEBUG) if OPTIONS[:log]

def elapsed(seconds)
    s = seconds % 60
    m = (seconds / 60) % 60
    h = seconds / 3600
    "%d:%02d:%02d" % [h,m,s]
end

def run(*args, &block)
    env = args.first.is_a?(Hash) ? args.shift : {}
    options = args.last.is_a?(Hash) ? args.pop : {}
    cmd = args.join(' ')
    Log.info "## COMMAND: #{cmd}"
    Open3.popen3(env, *args, options) do |i,o,e,t|
        if block_given?
            yield i,o,e
        else
            i.close
            {o => '>', e => '*'}.map do |io,s|
                Thread.start do
                    while line = io.gets.chomp rescue nil
                        Log.info "   #{s} #{line}"
                    end
                end
            end.each(&:join)
        end
        t.join
        raise "'#{cmd}' failed with exit code #{t.value.to_i}" unless t.value.success?
    end
end

def fetch(url, dir, branch)
    Log.info "=== Fetching #{url} to #{dir} (branch #{branch})"

    FileUtils.mkdir_p(dir) if !File.directory?(dir)
    FileUtils.cd(dir) do
        run 'git', 'init' unless File.exists?(File.join(dir, '.git'))
        run 'git', 'config', 'remote.origin.url', url
        run 'git', 'config', 'remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*'
        run 'git', 'fetch', '--prune', 'origin'
        run 'git', 'reset', '--hard'
        run 'git', 'clean', '-ffddx'
        ['git reset --hard', 'git clean -ffddx'].each do |cmd|
            run 'git', 'submodule', 'foreach', '--recursive', cmd
        end

        sha1, e, s = Open3.capture3("git rev-parse --verify origin/#{branch}")
        raise e unless s.success?
        sha1.chomp!
        raise "Can't detect SHA1 of branch #{branch}" if sha1.empty?

        run 'git', 'checkout', '-q', '-f', sha1
        run 'git', 'branch', '-D', branch rescue nil

        run 'git', 'checkout', '-b', branch
        run 'git', 'submodule', 'init'
        run 'git', 'submodule', 'sync', '--recursive'
        run 'git', 'submodule', 'update', '--recursive'
    end
end

def rm_rf(path)
    if File.directory?(path)
        run("rm -Rfv #{path}") do |i,o,e|
            i.close

            ot = Thread.start do
                cnt = 0
                total = 0
                while !o.gets.nil?
                    cnt += 1
                    next if cnt < 5000

                    total += cnt
                    cnt = 0
                    Log.info "#{total} files removed"
                end
                Log.info "#{total + cnt} files removed" if cnt > 0
            end

            et = Thread.start do
                while line = e.gets
                    Log.info "   * #{line}"
                end
            end

            ot.join
            et.join
        end
    else
        FileUtils.rm_rf path
    end
end

def fetch_boost_impl(url, dir, branch, name)
    6.times do |i|
        attempt = i + 1
        begin
            Log.notice "Fetching #{name} sources (attempt ##{attempt})"
            fetch url, dir, branch
            return true
        rescue => err
            Log.warning "Can't fetch #{url} to #{dir}: #{err.message}"
            rm_rf dir
            sleep attempt * 30
        end
    end
end

def fetch_boost(dir)
    fetch_boost_impl OPTIONS[:boost_url], dir, OPTIONS[:tag], "Boost"
end

def fetch_boost_bb(dir)
    fetch_boost_impl OPTIONS[:boost_build_url], dir, 'develop', "Boost.Build"
end

def fetch_boost_rr(dir)
    fetch_boost_impl OPTIONS[:boost_regression_url], dir, 'develop', "Boost.Regression"
end

def fetch_all
    if OPTIONS[:fetch_sources]
        fetch_boost BOOST_SRCDIR
        fetch_boost_bb BOOST_BB_SRCDIR
        fetch_boost_rr BOOST_RR_SRCDIR
    else
        raise "Boost sources are not fetched" unless File.directory?(BOOST_SRCDIR)
        raise "Boost.Build sources are not fetched" unless File.directory?(BOOST_BB_SRCDIR)
        raise "Boost.Regression sources are not fetched" unless File.directory?(BOOST_RR_SRCDIR)
    end
end

def generate_toolchain(abi, type, version, dir)
    apilevel = ['arm64-v8a', 'x86_64', 'mips64'].include?(abi) ? 21 : 9

    tcname = case abi
             when /^armeabi/
                 'arm-linux-androideabi'
             when /^arm64/
                 'aarch64-linux-android'
             when 'mips'
                 'mipsel-linux-android'
             when 'mips64'
                 'mips64el-linux-android'
             when 'x86', 'x86_64'
                 abi
             else
                 raise "Unknown ABI: #{abi}"
             end

    tcprefix = case abi
               when 'x86'
                   'i686-linux-android'
               when 'x86_64'
                   'x86_64-linux-android'
               else
                   tcname
               end

    llvmtripple = case abi
                  when 'armeabi'
                      'armv5te-none-linux-androideabi'
                  when /^armeabi-v7a/
                      'armv7-none-linux-androideabi'
                  when /^arm64/
                      'aarch64-none-linux-android'
                  when 'x86'
                      'i686-none-linux-android'
                  when 'x86_64'
                      'x86_64-none-linux-android'
                  when 'mips'
                      'mipsel-none-linux-android'
                  when 'mips64'
                      'mips64el-none-linux-android'
                  else
                      raise "Unknown ABI: #{abi}"
                  end

    arch = case abi
           when /^armeabi/
               'arm'
           when /^arm64/
               'arm64'
           else
               abi
           end

    flags = []
    ldflags = []
    case abi
    when 'armeabi'
        flags += ['-march=armv5te', '-mtune=xscale', '-msoft-float']
    when 'armeabi-v7a'
        flags += ['-march=armv7-a', '-mfpu=vfpv3-d16', '-mfloat-abi=softfp']
        ldflags << '-Wl,--fix-cortex-a8'
    when 'armeabi-v7a-hard'
        flags += ['-march=armv7-a', '-mfpu=vfpv3-d16', '-mhard-float']
        ldflags << '-Wl,--fix-cortex-a8'
        ldflags << '-Wl,--no-warn-mismatch'
    when 'x86'
        flags << '-m32'
    when 'x86_64'
        flags << '-m64'
    when 'mips'
        flags += ['-mabi=32', '-mips32']
    when 'mips64'
        flags += ['-mabi=64', '-mips64r6']
    end

    case RUBY_PLATFORM
    when /linux/
        hostos = 'linux'
    when /darwin/
        hostos = 'darwin'
    else
        raise "Unsupported host platform: #{RUBY_PLATFORM}"
    end

    hosttag = "%s-%s" % [hostos, `uname -m`.chomp]

    case type
    when :gcc
        gcctcpath = File.join(OPTIONS[:ndk], 'toolchains', "#{tcname}-#{version}", 'prebuilt', hosttag)
        ccs = ['gcc', 'g++']
        gnulibcxx_version = version
    when :clang
        llvmgccversion = '4.9'
        gnulibcxx_version = llvmgccversion
        gcctcpath = File.join(OPTIONS[:ndk], 'toolchains', "#{tcname}-#{llvmgccversion}", 'prebuilt', hosttag)
        llvmtcpath = File.join(OPTIONS[:ndk], 'toolchains', "llvm-#{version}", 'prebuilt', hosttag)
        ccs = ['clang', 'clang++']
    else
        raise "Unknown toolchain type: #{type.inspect}"
    end

    sysroot    = File.join(OPTIONS[:ndk], 'platforms', "android-#{apilevel}", "arch-#{arch}")
    libcrystax = File.join(OPTIONS[:ndk], 'sources', 'crystax')
    gnulibcxx  = File.join(OPTIONS[:ndk], 'sources', 'cxx-stl', 'gnu-libstdc++', gnulibcxx_version)
    compilerrt = File.join(OPTIONS[:ndk], 'sources', 'android', 'compiler-rt')

    flags << "--sysroot=#{sysroot}"
    flags << "-fPIC"
    if OPTIONS[:pie]
        flags << "-fPIE"
        ldflags << "-pie"
    end

    flags << '-g'

    ldlibs = ['gnustl_shared']
    ldlibs << 'compiler_rt_static' if type == :clang

    ccs.each do |cc|
        tool = File.join(dir, "#{cc}-#{version}")
        FileUtils.mkdir_p File.dirname(tool)
        File.open(tool, 'w') do |f|
            f.puts <<-EOF
#!/usr/bin/env ruby

require 'fileutils'

LINKER = !ARGV.include?('-c') && !ARGV.include?('-emit-pth')

# Remove any wrong input parameters
$args = ARGV.reject { |a| ['-m32', '-m64', '-lrt', '-pthread', '-lpthread'].include?(a) }

$target = nil
if LINKER
    next_arg_is_target = false
    $args.each do |a|
        $target = a if next_arg_is_target
        next_arg_is_target = (a == '-o')
    end
end

$flags = []

$flags += #{flags.inspect}

def add_libpath(d)
    $flags << ('-L%s' % d)
    File.open('%s.ldlp' % $target, 'a') do |f|
        f.puts d
    end unless $target.nil?
end

if LINKER
    $flags += #{ldflags.inspect}

    FileUtils.rm_f('%s.ldlp' % $target) unless $target.nil?

    add_libpath '#{File.join(libcrystax, 'libs', abi)}'
    add_libpath '#{File.join(gnulibcxx,  'libs', abi)}'

    $flags << '-L#{File.join(compilerrt, 'libs', abi)}'
else
    $flags += [
        '-I#{File.join(gnulibcxx, 'include')}',
        '-I#{File.join(gnulibcxx, 'include', 'backward')}',
        '-I#{File.join(gnulibcxx, 'libs', abi, 'include')}',
        '-I#{File.join(libcrystax, 'include')}',
        '-Wno-long-long',
    ]
end

$args = $flags + $args
$args += #{ldlibs.map { |l| "-l#{l}" }.inspect} if LINKER && !$target.nil?

def run(*a)
    File.open('#{WLOG}', 'a') do |f|
        f.flock(File::LOCK_EX)
        f.puts '## COMMAND: %s' % a.join(' ')
    end
    Kernel.exec(*a)
end

            EOF

            case type
            when :gcc
                exe = File.join(gcctcpath, 'bin', "#{tcprefix}-#{cc}")
                f.puts "run('#{exe}', *$args)"
            when :clang
                exe = File.join(llvmtcpath, 'bin', cc)
                f.puts "run('#{exe}', '-target', '#{llvmtripple}', '-gcc-toolchain', '#{gcctcpath}', *$args)"
            else
                raise "Wrong toolchain type: #{type.inspect}"
            end
        end

        FileUtils.chmod "a+x", tool
    end

    ['ar', 'as'].each do |t|
        tool = File.join(dir, t)
        FileUtils.mkdir_p File.dirname(tool)
        File.open(tool, 'w') do |f|
            f.puts <<-EOF
#!/usr/bin/env ruby

def run(*a)
    File.open('#{WLOG}', 'a') do |f|
        f.flock(File::LOCK_EX)
        f.puts '## COMMAND: %s' % a.join(' ')
    end
    Kernel.exec(*a)
end

            EOF

            case type
            when :gcc
                f.puts "run '#{File.join(gcctcpath, 'bin', "#{tcprefix}-#{t}")}', *ARGV"
            when :clang
                f.puts "run '#{File.join(llvmtcpath, 'bin', "llvm-#{t}")}', *ARGV"
            else
                raise "Wrong toolchain type: #{type.inspect}"
            end
        end

        FileUtils.chmod "a+x", tool
    end

    ['ranlib', 'strip'].each do |t|
        tool = File.join(dir, t)
        FileUtils.mkdir_p File.dirname(tool)
        File.open(tool, 'w') do |f|
            f.puts <<-EOF
#!/usr/bin/env ruby

def run(*a)
    File.open('#{WLOG}', 'a') do |f|
        f.flock(File::LOCK_EX)
        f.puts '## COMMAND: %s' % a.join(' ')
    end
    Kernel.exec(*a)
end

run '#{File.join(gcctcpath ,'bin', "#{tcprefix}-#{t}")}', *ARGV
            EOF
        end

        FileUtils.chmod "a+x", tool
    end
end

def generate_adbrunner(abi, dir, strip)
    libdir = File.join(dir, 'lib')
    FileUtils.rm_rf libdir

    adbrunner = File.join(dir, 'adbrunner')

    FileUtils.mkdir_p File.dirname(adbrunner)
    File.open(adbrunner, 'w') do |f|
        f.puts <<-EOF
#!/usr/bin/env ruby

skip = ['bcp-test']

exe = File.basename(ARGV.first) rescue nil

File.open('#{WLOG}', 'a') do |f|
    f.flock(File::LOCK_EX)
    f.puts '## COMMAND: %s' % ([$0] + ARGV).join(' ')

    if skip.include?(exe)
        f.puts "SKIP running %s on Android" % exe
        exit 0
    end
end

Kernel.exec('#{File.join(OPTIONS[:ndk], 'tools', 'adbrunner')}',
    #{"'--emulator-tag=#{OPTIONS[:emulator_tag]}'," unless OPTIONS[:emulator_tag].nil?}
    '--no-print-timestamps',
    '--log=#{WLOG}',
    '--abi=#{abi}',
    '--adb=#{OPTIONS[:adb]}',
    '--timeout=#{OPTIONS[:timeout]*60 - 5}',
    '--strip=#{strip}',
    '--lib-directory=#{libdir}',
    '--#{'no-' unless OPTIONS[:pie]}pie',
    *ARGV)
        EOF
    end

    FileUtils.chmod "a+x", adbrunner
end

def copy_boost(dir)
    # WARNING! This is intentionally just 'rm', not 'rm -rf'.
    # This is needed to remove $DIR if it's symlink.
    # Thus, we try to remove it and ignore any errors.
    # In case it's symlink - it will be removed.
    # In case it's directory - nothing will happen.
    FileUtils.rm_f dir rescue nil

    FileUtils.mkdir_p dir
    run 'rsync', '-a', "#{BOOST_SRCDIR}/", dir
end

def copy_boost_bb(dir)
    FileUtils.mkdir_p dir
    run 'rsync', '-a', "#{BOOST_BB_SRCDIR}/", dir
end

def copy_boost_rr(dir)
    FileUtils.mkdir_p dir
    run 'rsync', '-a', "#{BOOST_RR_SRCDIR}/", dir
end

PJL = "/tmp/process_jam_log.#{SecureRandom.uuid}"
at_exit { FileUtils.rm_f PJL }
$HOST_PJL = nil

def cleanup_pjl(dir)
    Dir.glob(File.join(dir, 'build', 'bin', '**', 'process_jam_log')).select do |e|
        File.file?(e)
    end.each do |f|
        FileUtils.rm_f f
    end
    return if $HOST_PJL.nil?

    pjl = File.join(dir, 'stage', 'bin', $HOST_PJL)
    FileUtils.mkdir_p File.dirname(pjl)
    FileUtils.cp PJL, pjl
end

def prepare_boost_tools(dir)
    FileUtils.mkdir_p dir

    runpy = File.join(dir, 'run.py')
    FileUtils.rm_f runpy
    FileUtils.cp File.join(BOOST_RR_SRCDIR, 'testing', 'src', 'run.py'), runpy
    FileUtils.chmod 'a+x', runpy

    boost_bb = File.join(dir, 'boost_bb')
    copy_boost_bb boost_bb

    boost_rr = File.join(dir, 'boost_regression')
    copy_boost_rr boost_rr

    [
        'collect_and_upload_logs.py',
        'process_jam_log.py',
        'regression.py',
    ].each do |t|
        FileUtils.rm_f File.join(dir, t)
        FileUtils.cp File.join(boost_rr, 'testing', 'src', t), dir
    end

    $HOST_PJL = nil
    cleanup_pjl boost_rr

    FileUtils.rm_f File.join(dir, 'user-config.jam')
    FileUtils.cd(dir) do
        run runpy, '--use-local', "--tag=#{OPTIONS[:tag]}", "--bjam-options=-j#{OPTIONS[:jobs]}", 'setup'
    end

    $HOST_PJL = Dir.glob(File.join(boost_rr, 'stage', 'bin', '**', 'process_jam_log')).select do |e|
        File.file?(e)
    end.map do |f|
        Pathname.new(f).relative_path_from(Pathname.new(File.join(boost_rr, 'stage', 'bin'))).to_s
    end.first
    raise "Can't find just built process_jam_log" if $HOST_PJL.nil?

    FileUtils.rm_f PJL
    FileUtils.cp File.join(boost_rr, 'stage', 'bin', $HOST_PJL), PJL
end

def generate_runner_comment(comment, configjam, compilers)
    FileUtils.mkdir_p File.dirname(comment)
    File.open(comment, 'w') do |f|
        File.open(OPTIONS[:runner_comment_header], 'r') do |r|
            while line = r.gets
                f.puts line
            end
        end unless OPTIONS[:runner_comment_header].nil?

        uname, e, s = Open3.capture3('uname -a')
        raise e unless s.success?

        f.puts <<-EOF
<p>
<pre>
$ uname -a
#{uname}
</pre>
<pre>
$ cat user-config.jam
#{File.read(configjam)}
</pre>
</p>
        EOF

        f.puts '<pre>'
        compilers.each do |cc|
            f.puts "$ #{cc} --version"
            f.puts `#{cc} --version 2>&1`.split("\n").select { |l| !l.empty? }.join("\n")
            f.puts ""
        end
        f.puts '</pre>'

        File.open(OPTIONS[:runner_comment_footer], 'r') do |r|
            while line = r.gets
                f.puts line
            end
        end unless OPTIONS[:runner_comment_footer].nil?
    end
end

def test_for_abi(abi, testdir)
    Log.notice "Run regression testing [#{abi}]"

    FileUtils.mkdir_p testdir

    srcdir = File.join(testdir, 'test')
    FileUtils.mkdir_p srcdir

    configjam = File.join(testdir, 'config.jam')
    FileUtils.rm_f configjam

    toolsets = []
    toolsets_path = []
    cxxbins = []
    strip = nil

    OPTIONS[:toolchain_versions].each do |tv|
        if tv =~ /^clang/
            ttype = :clang
            tversion = tv.sub(/^clang-?/, '')
            cxxbin = "clang++-#{tversion}"
        else
            ttype = :gcc
            tversion = tv.sub(/^gcc-?/, '')
            cxxbin = "g++-#{tversion}"
        end

        # clang toolchains don't support armeabi good
        next if ttype == :clang && abi == 'armeabi'

        # gcc-4.8 don't support 64-bit targets
        next if ttype == :gcc && tversion == '4.8' && ['arm64-v8a', 'x86_64', 'mips64'].include?(abi)

        toolset = "#{ttype}-#{tversion}"

        targetbin = File.join(testdir, toolset)
        FileUtils.rm_rf targetbin

        # Generate toolchain wrappers
        generate_toolchain abi, ttype, tversion, targetbin

        toolsets << toolset
        toolsets_path << targetbin

        File.open(configjam, "a") do |f|
            f.puts "using #{ttype} : #{tversion} : #{targetbin}/#{cxxbin} ;"
        end

        cxxbins << File.join(targetbin, cxxbin)

        strip = File.join(targetbin, 'strip') if strip.nil? && File.executable?(File.join(targetbin, 'strip'))
    end

    raise "No C++ compilers detected" if cxxbins.empty?
    raise "Can't detect 'strip' for #{abi}" if strip.nil?

    generate_adbrunner abi, testdir, strip

    copy_boost File.join(srcdir, 'boost_root')
    prepare_boost_tools srcdir

    comment = File.join(srcdir, 'comment.html')
    generate_runner_comment comment, configjam, cxxbins

    runpy = [
        File.join(srcdir, 'run.py'),
        '--use-local',
        '--platform=Android',
        "--tag=#{OPTIONS[:tag]}",
        "--runner=#{OPTIONS[:runner]}",
        "--toolsets=#{toolsets.join(',')}",
    ]

    bjam_options = [
        "-j#{OPTIONS[:jobs]}",
        "variant=release",
        "link=static,shared",
        "runtime-link=shared",
        "threading=multi",
        "target-os=android",
        "testing.launcher=#{File.join(testdir, 'adbrunner')}",
    ]

    bjam_options << "cxxflags='-std=#{OPTIONS[:std]}'" unless OPTIONS[:std].nil?

    resultsdir = File.join(srcdir, 'results')
    if File.directory?(resultsdir)
        # Remove this directory, but keep *.zip
        tmpresults = File.join(srcdir, "results.#{SecureRandom.uuid}")
        FileUtils.rm_rf tmpresults
        FileUtils.mkdir_p File.dirname(tmpresults)
        FileUtils.mv resultsdir, tmpresults
        FileUtils.mkdir_p resultsdir
        Dir.glob(File.join(tmpresults, '*.zip')).each do |zip|
            FileUtils.mv zip, resultsdir
        end

        rm_rf tmpresults
    else
        FileUtils.mkdir_p resultsdir
    end

    actions = ['test-run']
    actions += ['test-process', 'collect-logs', 'upload-logs'] if OPTIONS[:publish]

    userconfigjam = File.join(srcdir, 'user-config.jam')
    at_exit { FileUtils.rm_f userconfigjam }
    FileUtils.rm_f userconfigjam
    FileUtils.cp configjam, userconfigjam

    FileUtils.cd(srcdir) do
        actions.each do |action|
            Log.info "=== run.py: #{action}"

            cleanup_pjl File.join(srcdir, 'boost_regression')

            case action
            when 'test-run'
                args = runpy.dup
                args += [
                    "--comment=#{comment}",
                    "--timeout=#{OPTIONS[:timeout]}",
                    "--bjam-options=#{bjam_options.join(' ')}",
                ]
                args << "--libraries=#{OPTIONS[:libraries].join(',')}" unless OPTIONS[:libraries].nil?
                args << action
                run(*args)

                bjamlog = File.join(resultsdir, 'bjam.log')
                raise "Can't find #{bjamlog} after finishing 'test-run'" unless File.exists?(bjamlog)
                bjamlast = `tail -n 20 #{bjamlog}`.split("\n").map(&:chomp).reject(&:empty?)
                raise "Bjam failed (see #{bjamlog} for full details):\n#{bjamlast.join("\n")}" if bjamlast.last.to_s =~ /^error:/
            when 'test-process'
                run(*runpy, '--verbose-log-processing', action) do |i,o,e|
                    i.close

                    wt = Thread.start do
                        s = Time.now
                        while true
                            sleep 120
                            Log.info "test-process: #{elapsed(Time.now - s)}"
                        end
                    end

                    ot = Thread.start do
                        cnt = 0
                        total = 0
                        while !o.gets.nil?
                            cnt += 1
                            next if cnt < 5000

                            total += cnt
                            cnt = 0
                            Log.info "#{total} lines processed"
                        end
                        if cnt > 0
                            total += cnt
                            Log.info "#{total} lines processed"
                        end
                    end

                    et = Thread.start do
                        while line = e.gets.chomp rescue nil
                            Log.info "   * #{line}" rescue nil
                        end
                    end

                    ot.join
                    et.join
                    wt.kill
                end
            when 'collect-logs'
                run(*runpy, action) do |i,o,e|
                    i.close

                    wt = Thread.start do
                        s = Time.now
                        while true
                            sleep 120
                            Log.info "collect-logs: #{elapsed(Time.now - s)}"
                        end
                    end

                    ot = Thread.start do
                        while line = o.gets.chomp rescue nil
                            Log.info "   > #{line}" rescue nil
                        end
                    end

                    et = Thread.start do
                        cnt = 0
                        total = 0
                        while !e.gets.nil?
                            cnt += 1
                            next if cnt < 5000

                            total += cnt
                            cnt = 0
                            Log.info "#{total} logs collected"
                        end
                        Log.info "#{total + cnt} logs collected" if cnt > 0
                    end

                    ot.join
                    et.join
                    wt.kill
                end
            else
                run(*runpy, action)
            end
        end
    end
end

def test
    fetch_all

    wpid = nil
    wth = Thread.start do
        Open3.popen3("tail -F #{WLOG}") do |i,o,e,t|
            wpid = t.pid

            i.close

            ot = Thread.start do
                while line = o.gets.chomp rescue nil
                    Log.info line
                end
            end

            et = Thread.start do
                while line = e.gets.chomp rescue nil
                    Log.error line
                end
            end

            ot.join
            et.join

            t.join
        end
    end
    at_exit do
        Process.kill('KILL', wpid) rescue nil
        wth.kill
    end

    OPTIONS[:abis].each do |abi|
        test_for_abi abi, File.join(REGRESSION_DIR, abi)
    end
end

begin
    start = Time.now
    test
    Log.notice "=== DONE (took #{elapsed(Time.now - start)})"
rescue Interrupt
    Log.info "\n\nINTERRUPTED"
    exit 1
rescue RuntimeError => err
    Log.error err.message
    exit 1
end