[ceph.git] / ceph / src / rocksdb / build_tools / rocksdb-lego-determinator

#!/usr/bin/env bash
# This script is executed by Sandcastle
# to determine next steps to run

# Usage:
# EMAIL=<email> ONCALL=<email> TRIGGER=<trigger> SUBSCRIBER=<email> rocks_ci.py <test-name>
#
# Input         Value
# -------------------------------------------------------------------------
# EMAIL         Email address to report on trigger conditions
# ONCALL        Email address to raise a task on failure
# TRIGGER       Trigger conditions for email. Valid values are fail, warn, all
# SUBSCRIBER    Email addresss to add as subscriber for task
#

#
# Report configuration
#
REPORT_EMAIL=
if [ ! -z $EMAIL ]; then
  if [ -z $TRIGGER ]; then
    TRIGGER="fail"
  fi

  REPORT_EMAIL="
  {
      'type':'email',
      'triggers': [ '$TRIGGER' ],
      'emails':['$EMAIL']
  },"
fi

CREATE_TASK=
if [ ! -z $ONCALL ]; then
  CREATE_TASK="
  {
      'type':'task',
      'triggers':[ 'fail' ],
      'priority':0,
      'subscribers':[ '$SUBSCRIBER' ],
      'tags':[ 'rocksdb', 'ci' ],
  },"
fi

# For now, create the tasks using only the dedicated task creation tool.
CREATE_TASK=

REPORT=
if [[ ! -z $REPORT_EMAIL || ! -z $CREATE_TASK ]]; then
  REPORT="'report': [
    $REPORT_EMAIL
    $CREATE_TASK
  ]"
fi

#
# Helper variables
#
CLEANUP_ENV="
{
    'name':'Cleanup environment',
    'shell':'rm -rf /dev/shm/rocksdb && mkdir /dev/shm/rocksdb && (chmod +t /dev/shm || true)  && make clean',
    'user':'root'
}"

# We will eventually set the RATIO to 1, but we want do this
# in steps. RATIO=$(nproc) will make it work as J=1
if [ -z $RATIO ]; then
  RATIO=$(nproc)
fi

if [ -z $PARALLEL_J ]; then
  PARALLEL_J="J=$(expr $(nproc) / ${RATIO})"
fi

if [ -z $PARALLEL_j ]; then
  PARALLEL_j="-j$(expr $(nproc) / ${RATIO})"
fi

PARALLELISM="$PARALLEL_J $PARALLEL_j"

DEBUG="OPT=-g"
SHM="TEST_TMPDIR=/dev/shm/rocksdb"
NON_SHM="TMPD=/tmp/rocksdb_test_tmp"
GCC_481="ROCKSDB_FBCODE_BUILD_WITH_481=1"
ASAN="COMPILE_WITH_ASAN=1"
CLANG="USE_CLANG=1"
LITE="OPT=\"-DROCKSDB_LITE -g\""
TSAN="COMPILE_WITH_TSAN=1"
UBSAN="COMPILE_WITH_UBSAN=1"
TSAN_CRASH='CRASH_TEST_EXT_ARGS="--compression_type=zstd --log2_keys_per_lock=22"'
NON_TSAN_CRASH="CRASH_TEST_EXT_ARGS=--compression_type=zstd"
DISABLE_JEMALLOC="DISABLE_JEMALLOC=1"
HTTP_PROXY="https_proxy=http://fwdproxy.29.prn1:8080 http_proxy=http://fwdproxy.29.prn1:8080 ftp_proxy=http://fwdproxy.29.prn1:8080"
SETUP_JAVA_ENV="export $HTTP_PROXY; export JAVA_HOME=/usr/local/jdk-8u60-64/; export PATH=\$JAVA_HOME/bin:\$PATH"
PARSER="'parser':'python build_tools/error_filter.py $1'"

CONTRUN_NAME="ROCKSDB_CONTRUN_NAME"

# This code is getting called under various scenarios. What we care about is to
# understand when it's called from nightly contruns because in that case we'll
# create tasks for any failures. To follow the existing pattern, we'll check
# the value of $ONCALL. If it's a diff then just call `false` to make sure
# that errors will be properly propagated to the caller.
if [ ! -z $ONCALL ]; then
  TASK_CREATION_TOOL="/usr/local/bin/mysql_mtr_filter --rocksdb --oncall $ONCALL"
else
  TASK_CREATION_TOOL="false"
fi

ARTIFACTS=" 'artifacts': [
    {
        'name':'database',
        'paths':[ '/dev/shm/rocksdb' ],
    }
]"

#
# A mechanism to disable tests temporarily
#
DISABLE_COMMANDS="[
    {
        'name':'Disable test',
        'oncall':'$ONCALL',
        'steps': [
            {
              'name':'Job disabled. Please contact test owner',
              'shell':'exit 1',
              'user':'root'
            },
        ],
    }
]"

#
# RocksDB unit test
#
UNIT_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and test RocksDB debug version',
                'shell':'$SHM $DEBUG make $PARALLELISM check || $CONTRUN_NAME=check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB unit test not under /dev/shm
#
UNIT_TEST_NON_SHM_COMMANDS="[
    {
        'name':'Rocksdb Unit Test',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and test RocksDB debug version',
                'timeout': 86400,
                'shell':'$NON_SHM $DEBUG make $PARALLELISM check || $CONTRUN_NAME=non_shm_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB release build and unit tests
#
RELEASE_BUILD_COMMANDS="[
    {
        'name':'Rocksdb Release Build',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build RocksDB release',
                'shell':'make $PARALLEL_j release || $CONTRUN_NAME=release $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB unit test on gcc-4.8.1
#
UNIT_TEST_COMMANDS_481="[
    {
        'name':'Rocksdb Unit Test on GCC 4.8.1',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and test RocksDB debug version',
                'shell':'$SHM $GCC_481 $DEBUG make $PARALLELISM check || $CONTRUN_NAME=unit_gcc_481_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB release build and unit tests
#
RELEASE_BUILD_COMMANDS_481="[
    {
        'name':'Rocksdb Release on GCC 4.8.1',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build RocksDB release on GCC 4.8.1',
                'shell':'$GCC_481 make $PARALLEL_j release || $CONTRUN_NAME=release_gcc481 $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB unit test with CLANG
#
CLANG_UNIT_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and test RocksDB debug',
                'shell':'$CLANG $SHM $DEBUG make $PARALLELISM check || $CONTRUN_NAME=clang_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB release build with CLANG
#
CLANG_RELEASE_BUILD_COMMANDS="[
    {
        'name':'Rocksdb CLANG Release Build',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build RocksDB release',
                'shell':'$CLANG make $PARALLEL_j release|| $CONTRUN_NAME=clang_release $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB analyze
#
CLANG_ANALYZE_COMMANDS="[
    {
        'name':'Rocksdb analyze',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'RocksDB build and analyze',
                'shell':'$CLANG $SHM $DEBUG make $PARALLEL_j analyze || $CONTRUN_NAME=clang_analyze $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB code coverage
#
CODE_COV_COMMANDS="[
    {
        'name':'Rocksdb Unit Test Code Coverage',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build, test and collect code coverage info',
                'shell':'$SHM $DEBUG make $PARALLELISM coverage || $CONTRUN_NAME=coverage $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB unity
#
UNITY_COMMANDS="[
    {
        'name':'Rocksdb Unity',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build, test unity test',
                'shell':'$SHM $DEBUG V=1 make J=1 unity_test || $CONTRUN_NAME=unity_test $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# Build RocksDB lite
#
LITE_BUILD_COMMANDS="[
    {
        'name':'Rocksdb Lite build',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build RocksDB debug version',
                'shell':'$LITE make J=1 all check || $CONTRUN_NAME=lite $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# Report RocksDB lite binary size to scuba
REPORT_LITE_BINARY_SIZE_COMMANDS="[
    {
        'name':'Rocksdb Lite Binary Size',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Report RocksDB Lite binary size to scuba',
                'shell':'tools/report_lite_binary_size.sh',
                'user':'root',
            },
        ],
]"

#
# RocksDB stress/crash test
#
STRESS_CRASH_TEST_COMMANDS="[
    {
        'name':'Rocksdb Stress/Crash Test',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and run RocksDB debug stress tests',
                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 db_stress || $CONTRUN_NAME=db_stress $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
            {
                'name':'Build and run RocksDB debug crash tests',
                'timeout': 86400,
                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test || $CONTRUN_NAME=crash_test $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            }
        ],
        $ARTIFACTS,
        $REPORT
    }
]"

# RocksDB write stress test.
# We run on disk device on purpose (i.e. no $SHM)
# because we want to add some randomness to fsync commands
WRITE_STRESS_COMMANDS="[
    {
        'name':'Rocksdb Write Stress Test',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and run RocksDB write stress tests',
                'shell':'make write_stress && python tools/write_stress_runner.py --runtime_sec=3600 --db=/tmp/rocksdb_write_stress || $CONTRUN_NAME=write_stress $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            }
        ],
        'artifacts': [{'name': 'database', 'paths': ['/tmp/rocksdb_write_stress']}],
        $REPORT
    }
]"


#
# RocksDB test under address sanitizer
#
ASAN_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test under ASAN',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Test RocksDB debug under ASAN',
'shell':'set -o pipefail && ($SHM $ASAN $DEBUG make $PARALLELISM asan_check || $CONTRUN_NAME=asan_check $TASK_CREATION_TOOL) |& /usr/facebook/ops/scripts/asan_symbolize.py -d',
                'user':'root',
                $PARSER
            }
        ],
        $REPORT
    }
]"

#
# RocksDB crash testing under address sanitizer
#
ASAN_CRASH_TEST_COMMANDS="[
    {
        'name':'Rocksdb crash test under ASAN',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and run RocksDB debug asan_crash_test',
                'timeout': 86400,
                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 asan_crash_test || $CONTRUN_NAME=asan_crash_test $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB test under undefined behavior sanitizer
#
UBSAN_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test under UBSAN',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Test RocksDB debug under UBSAN',
                'shell':'set -o pipefail && $SHM $UBSAN $DEBUG make $PARALLELISM ubsan_check || $CONTRUN_NAME=ubsan_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            }
        ],
        $REPORT
    }
]"

#
# RocksDB crash testing under udnefined behavior sanitizer
#
UBSAN_CRASH_TEST_COMMANDS="[
    {
        'name':'Rocksdb crash test under UBSAN',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build and run RocksDB debug ubsan_crash_test',
                'timeout': 86400,
                'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 ubsan_crash_test || $CONTRUN_NAME=ubsan_crash_test $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB unit test under valgrind
#
VALGRIND_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test under valgrind',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Run RocksDB debug unit tests',
                'timeout': 86400,
                'shell':'$SHM $DEBUG make $PARALLELISM valgrind_test || $CONTRUN_NAME=valgrind_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB test under TSAN
#
TSAN_UNIT_TEST_COMMANDS="[
    {
        'name':'Rocksdb Unit Test under TSAN',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Run RocksDB debug unit test',
                'timeout': 86400,
                'shell':'set -o pipefail && $SHM $DEBUG $TSAN make $PARALLELISM check || $CONTRUN_NAME=tsan_check $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB crash test under TSAN
#
TSAN_CRASH_TEST_COMMANDS="[
    {
        'name':'Rocksdb Crash Test under TSAN',
        'oncall':'$ONCALL',
        'timeout': 86400,
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Compile and run',
                'timeout': 86400,
                'shell':'set -o pipefail && $SHM $DEBUG $TSAN $TSAN_CRASH CRASH_TEST_KILL_ODD=1887 make J=1 crash_test || $CONTRUN_NAME=tsan_crash_test $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB format compatible
#

run_format_compatible()
{
  export TEST_TMPDIR=/dev/shm/rocksdb
  rm -rf /dev/shm/rocksdb
  mkdir /dev/shm/rocksdb

  tools/check_format_compatible.sh
}

FORMAT_COMPATIBLE_COMMANDS="[
    {
        'name':'Rocksdb Format Compatible tests',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Run RocksDB debug unit test',
                'shell':'build_tools/rocksdb-lego-determinator run_format_compatible || $CONTRUN_NAME=run_format_compatible $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB no compression
#
run_no_compression()
{
  export TEST_TMPDIR=/dev/shm/rocksdb
  rm -rf /dev/shm/rocksdb
  mkdir /dev/shm/rocksdb
  make clean
  cat build_tools/fbcode_config.sh | grep -iv dzlib | grep -iv dlz4 | grep -iv dsnappy | grep -iv dbzip2 > .tmp.fbcode_config.sh
  mv .tmp.fbcode_config.sh build_tools/fbcode_config.sh
  cat Makefile | grep -v tools/ldb_test.py > .tmp.Makefile
  mv .tmp.Makefile Makefile
  make $DEBUG J=1 check
}

NO_COMPRESSION_COMMANDS="[
    {
        'name':'Rocksdb No Compression tests',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Run RocksDB debug unit test',
                'shell':'build_tools/rocksdb-lego-determinator run_no_compression || $CONTRUN_NAME=run_no_compression $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB regression
#
run_regression()
{
  time -v bash -vx ./build_tools/regression_build_test.sh $(mktemp -d  $WORKSPACE/leveldb.XXXX) $(mktemp leveldb_test_stats.XXXX)

  # ======= report size to ODS ========

  # parameters: $1 -- key, $2 -- value
  function send_size_to_ods {
    curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=rocksdb.build_size.$1&value=$2" \
      --connect-timeout 60
  }

  # === normal build ===
  make clean
  make -j$(nproc) static_lib
  send_size_to_ods static_lib $(stat --printf="%s" librocksdb.a)
  strip librocksdb.a
  send_size_to_ods static_lib_stripped $(stat --printf="%s" librocksdb.a)

  make -j$(nproc) shared_lib
  send_size_to_ods shared_lib $(stat --printf="%s" `readlink -f librocksdb.so`)
  strip `readlink -f librocksdb.so`
  send_size_to_ods shared_lib_stripped $(stat --printf="%s" `readlink -f librocksdb.so`)

  # === lite build ===
  make clean
  OPT=-DROCKSDB_LITE make -j$(nproc) static_lib
  send_size_to_ods static_lib_lite $(stat --printf="%s" librocksdb.a)
  strip librocksdb.a
  send_size_to_ods static_lib_lite_stripped $(stat --printf="%s" librocksdb.a)

  OPT=-DROCKSDB_LITE make -j$(nproc) shared_lib
  send_size_to_ods shared_lib_lite $(stat --printf="%s" `readlink -f librocksdb.so`)
  strip `readlink -f librocksdb.so`
  send_size_to_ods shared_lib_lite_stripped $(stat --printf="%s" `readlink -f librocksdb.so`)
}

REGRESSION_COMMANDS="[
    {
        'name':'Rocksdb regression commands',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Make and run script',
                'shell':'build_tools/rocksdb-lego-determinator run_regression || $CONTRUN_NAME=run_regression $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"

#
# RocksDB Java build
#
JAVA_BUILD_TEST_COMMANDS="[
    {
        'name':'Rocksdb Java Build',
        'oncall':'$ONCALL',
        'steps': [
            $CLEANUP_ENV,
            {
                'name':'Build RocksDB for Java',
                'shell':'$SETUP_JAVA_ENV; $SHM make rocksdbjava || $CONTRUN_NAME=rocksdbjava $TASK_CREATION_TOOL',
                'user':'root',
                $PARSER
            },
        ],
        $REPORT
    }
]"


case $1 in
  unit)
    echo $UNIT_TEST_COMMANDS
    ;;
  unit_non_shm)
    echo $UNIT_TEST_NON_SHM_COMMANDS
    ;;
  release)
    echo $RELEASE_BUILD_COMMANDS
    ;;
  unit_481)
    echo $UNIT_TEST_COMMANDS_481
    ;;
  release_481)
    echo $RELEASE_BUILD_COMMANDS_481
    ;;
  clang_unit)
    echo $CLANG_UNIT_TEST_COMMANDS
    ;;
  clang_release)
    echo $CLANG_RELEASE_BUILD_COMMANDS
    ;;
  clang_analyze)
    echo $CLANG_ANALYZE_COMMANDS
    ;;
  code_cov)
    echo $CODE_COV_COMMANDS
    ;;
  unity)
    echo $UNITY_COMMANDS
    ;;
  lite)
    echo $LITE_BUILD_COMMANDS
    ;;
  report_lite_binary_size)
    echo $REPORT_LITE_BINARY_SIZE_COMMANDS
    ;;
  stress_crash)
    echo $STRESS_CRASH_TEST_COMMANDS
    ;;
  write_stress)
    echo $WRITE_STRESS_COMMANDS
    ;;
  asan)
    echo $ASAN_TEST_COMMANDS
    ;;
  asan_crash)
    echo $ASAN_CRASH_TEST_COMMANDS
    ;;
  ubsan)
    echo $UBSAN_TEST_COMMANDS
    ;;
  ubsan_crash)
    echo $UBSAN_CRASH_TEST_COMMANDS
    ;;
  valgrind)
    echo $VALGRIND_TEST_COMMANDS
    ;;
  tsan)
    echo $TSAN_UNIT_TEST_COMMANDS
    ;;
  tsan_crash)
    echo $TSAN_CRASH_TEST_COMMANDS
    ;;
  format_compatible)
    echo $FORMAT_COMPATIBLE_COMMANDS
    ;;
  run_format_compatible)
    run_format_compatible
    ;;
  no_compression)
    echo $NO_COMPRESSION_COMMANDS
    ;;
  run_no_compression)
    run_no_compression
    ;;
  regression)
    echo $REGRESSION_COMMANDS
    ;;
  run_regression)
    run_regression
    ;;
  java_build)
    echo $JAVA_BUILD_TEST_COMMANDS
    ;;
  *)
    echo "Invalid determinator command"
    ;;
esac
Commit	Line	Data
11fdf7f2	1	#!/usr/bin/env bash
7c673cae FG	2	# This script is executed by Sandcastle
	3	# to determine next steps to run
	4
	5	# Usage:
	6	# EMAIL=<email> ONCALL=<email> TRIGGER=<trigger> SUBSCRIBER=<email> rocks_ci.py <test-name>
	7	#
	8	# Input Value
	9	# -------------------------------------------------------------------------
	10	# EMAIL Email address to report on trigger conditions
	11	# ONCALL Email address to raise a task on failure
	12	# TRIGGER Trigger conditions for email. Valid values are fail, warn, all
	13	# SUBSCRIBER Email addresss to add as subscriber for task
	14	#
	15
	16	#
	17	# Report configuration
	18	#
	19	REPORT_EMAIL=
	20	if [ ! -z $EMAIL ]; then
	21	if [ -z $TRIGGER ]; then
	22	TRIGGER="fail"
	23	fi
	24
	25	REPORT_EMAIL="
	26	{
	27	'type':'email',
	28	'triggers': [ '$TRIGGER' ],
	29	'emails':['$EMAIL']
	30	},"
	31	fi
	32
	33	CREATE_TASK=
	34	if [ ! -z $ONCALL ]; then
	35	CREATE_TASK="
	36	{
	37	'type':'task',
	38	'triggers':[ 'fail' ],
	39	'priority':0,
	40	'subscribers':[ '$SUBSCRIBER' ],
	41	'tags':[ 'rocksdb', 'ci' ],
	42	},"
	43	fi
	44
	45	# For now, create the tasks using only the dedicated task creation tool.
	46	CREATE_TASK=
	47
	48	REPORT=
	49	if [[ ! -z $REPORT_EMAIL \|\| ! -z $CREATE_TASK ]]; then
	50	REPORT="'report': [
	51	$REPORT_EMAIL
	52	$CREATE_TASK
	53	]"
	54	fi
	55
	56	#
	57	# Helper variables
	58	#
	59	CLEANUP_ENV="
	60	{
	61	'name':'Cleanup environment',
	62	'shell':'rm -rf /dev/shm/rocksdb && mkdir /dev/shm/rocksdb && (chmod +t /dev/shm \|\| true) && make clean',
	63	'user':'root'
	64	}"
	65
66	# We will eventually set the RATIO to 1, but we want do this
67	# in steps. RATIO=$(nproc) will make it work as J=1
68	if [ -z $RATIO ]; then
69	RATIO=$(nproc)
70	fi
71
72	if [ -z $PARALLEL_J ]; then
73	PARALLEL_J="J=$(expr $(nproc) / ${RATIO})"
74	fi
75
76	if [ -z $PARALLEL_j ]; then
77	PARALLEL_j="-j$(expr $(nproc) / ${RATIO})"
78	fi
79
80	PARALLELISM="$PARALLEL_J $PARALLEL_j"
81
82	DEBUG="OPT=-g"
83	SHM="TEST_TMPDIR=/dev/shm/rocksdb"
84	NON_SHM="TMPD=/tmp/rocksdb_test_tmp"
85	GCC_481="ROCKSDB_FBCODE_BUILD_WITH_481=1"
86	ASAN="COMPILE_WITH_ASAN=1"
87	CLANG="USE_CLANG=1"
88	LITE="OPT=\"-DROCKSDB_LITE -g\""
89	TSAN="COMPILE_WITH_TSAN=1"
90	UBSAN="COMPILE_WITH_UBSAN=1"
11fdf7f2 TL	91	TSAN_CRASH='CRASH_TEST_EXT_ARGS="--compression_type=zstd --log2_keys_per_lock=22"'
11fdf7f2 TL	92	NON_TSAN_CRASH="CRASH_TEST_EXT_ARGS=--compression_type=zstd"
7c673cae FG	93	DISABLE_JEMALLOC="DISABLE_JEMALLOC=1"
	94	HTTP_PROXY="https_proxy=http://fwdproxy.29.prn1:8080 http_proxy=http://fwdproxy.29.prn1:8080 ftp_proxy=http://fwdproxy.29.prn1:8080"
	95	SETUP_JAVA_ENV="export $HTTP_PROXY; export JAVA_HOME=/usr/local/jdk-8u60-64/; export PATH=\$JAVA_HOME/bin:\$PATH"
	96	PARSER="'parser':'python build_tools/error_filter.py $1'"
	97
	98	CONTRUN_NAME="ROCKSDB_CONTRUN_NAME"
	99
	100	# This code is getting called under various scenarios. What we care about is to
	101	# understand when it's called from nightly contruns because in that case we'll
	102	# create tasks for any failures. To follow the existing pattern, we'll check
	103	# the value of $ONCALL. If it's a diff then just call `false` to make sure
	104	# that errors will be properly propagated to the caller.
	105	if [ ! -z $ONCALL ]; then
	106	TASK_CREATION_TOOL="/usr/local/bin/mysql_mtr_filter --rocksdb --oncall $ONCALL"
	107	else
	108	TASK_CREATION_TOOL="false"
	109	fi
	110
	111	ARTIFACTS=" 'artifacts': [
	112	{
	113	'name':'database',
	114	'paths':[ '/dev/shm/rocksdb' ],
	115	}
	116	]"
	117
	118	#
	119	# A mechanism to disable tests temporarily
	120	#
	121	DISABLE_COMMANDS="[
	122	{
	123	'name':'Disable test',
	124	'oncall':'$ONCALL',
	125	'steps': [
	126	{
	127	'name':'Job disabled. Please contact test owner',
	128	'shell':'exit 1',
	129	'user':'root'
	130	},
	131	],
	132	}
	133	]"
	134
7c673cae FG	135	#
	136	# RocksDB unit test
	137	#
	138	UNIT_TEST_COMMANDS="[
	139	{
	140	'name':'Rocksdb Unit Test',
	141	'oncall':'$ONCALL',
	142	'steps': [
	143	$CLEANUP_ENV,
	144	{
	145	'name':'Build and test RocksDB debug version',
	146	'shell':'$SHM $DEBUG make $PARALLELISM check \|\| $CONTRUN_NAME=check $TASK_CREATION_TOOL',
	147	'user':'root',
	148	$PARSER
	149	},
	150	],
	151	$REPORT
	152	}
	153	]"
	154
	155	#
	156	# RocksDB unit test not under /dev/shm
	157	#
	158	UNIT_TEST_NON_SHM_COMMANDS="[
	159	{
	160	'name':'Rocksdb Unit Test',
	161	'oncall':'$ONCALL',
	162	'timeout': 86400,
	163	'steps': [
	164	$CLEANUP_ENV,
	165	{
	166	'name':'Build and test RocksDB debug version',
	167	'timeout': 86400,
	168	'shell':'$NON_SHM $DEBUG make $PARALLELISM check \|\| $CONTRUN_NAME=non_shm_check $TASK_CREATION_TOOL',
	169	'user':'root',
	170	$PARSER
	171	},
	172	],
	173	$REPORT
	174	}
	175	]"
	176
	177	#
	178	# RocksDB release build and unit tests
	179	#
	180	RELEASE_BUILD_COMMANDS="[
	181	{
	182	'name':'Rocksdb Release Build',
	183	'oncall':'$ONCALL',
	184	'steps': [
	185	$CLEANUP_ENV,
	186	{
	187	'name':'Build RocksDB release',
	188	'shell':'make $PARALLEL_j release \|\| $CONTRUN_NAME=release $TASK_CREATION_TOOL',
	189	'user':'root',
	190	$PARSER
	191	},
	192	],
	193	$REPORT
	194	}
	195	]"
	196
	197	#
	198	# RocksDB unit test on gcc-4.8.1
199	#
200	UNIT_TEST_COMMANDS_481="[
201	{
202	'name':'Rocksdb Unit Test on GCC 4.8.1',
203	'oncall':'$ONCALL',
204	'steps': [
205	$CLEANUP_ENV,
206	{
207	'name':'Build and test RocksDB debug version',
208	'shell':'$SHM $GCC_481 $DEBUG make $PARALLELISM check \|\| $CONTRUN_NAME=unit_gcc_481_check $TASK_CREATION_TOOL',
209	'user':'root',
210	$PARSER
211	},
212	],
213	$REPORT
214	}
215	]"
216
217	#
218	# RocksDB release build and unit tests
219	#
220	RELEASE_BUILD_COMMANDS_481="[
221	{
222	'name':'Rocksdb Release on GCC 4.8.1',
223	'oncall':'$ONCALL',
224	'steps': [
225	$CLEANUP_ENV,
226	{
227	'name':'Build RocksDB release on GCC 4.8.1',
228	'shell':'$GCC_481 make $PARALLEL_j release \|\| $CONTRUN_NAME=release_gcc481 $TASK_CREATION_TOOL',
229	'user':'root',
230	$PARSER
231	},
232	],
233	$REPORT
234	}
235	]"
236
237	#
238	# RocksDB unit test with CLANG
239	#
240	CLANG_UNIT_TEST_COMMANDS="[
241	{
242	'name':'Rocksdb Unit Test',
243	'oncall':'$ONCALL',
244	'steps': [
245	$CLEANUP_ENV,
246	{
247	'name':'Build and test RocksDB debug',
248	'shell':'$CLANG $SHM $DEBUG make $PARALLELISM check \|\| $CONTRUN_NAME=clang_check $TASK_CREATION_TOOL',
249	'user':'root',
250	$PARSER
251	},
252	],
253	$REPORT
254	}
255	]"
256
257	#
258	# RocksDB release build with CLANG
259	#
260	CLANG_RELEASE_BUILD_COMMANDS="[
261	{
262	'name':'Rocksdb CLANG Release Build',
263	'oncall':'$ONCALL',
264	'steps': [
265	$CLEANUP_ENV,
266	{
267	'name':'Build RocksDB release',
268	'shell':'$CLANG make $PARALLEL_j release\|\| $CONTRUN_NAME=clang_release $TASK_CREATION_TOOL',
269	'user':'root',
270	$PARSER
271	},
272	],
273	$REPORT
274	}
275	]"
276
277	#
278	# RocksDB analyze
279	#
280	CLANG_ANALYZE_COMMANDS="[
281	{
282	'name':'Rocksdb analyze',
283	'oncall':'$ONCALL',
284	'steps': [
285	$CLEANUP_ENV,
286	{
287	'name':'RocksDB build and analyze',
288	'shell':'$CLANG $SHM $DEBUG make $PARALLEL_j analyze \|\| $CONTRUN_NAME=clang_analyze $TASK_CREATION_TOOL',
289	'user':'root',
290	$PARSER
291	},
292	],
293	$REPORT
294	}
295	]"
296
297	#
298	# RocksDB code coverage
299	#
300	CODE_COV_COMMANDS="[
301	{
302	'name':'Rocksdb Unit Test Code Coverage',
303	'oncall':'$ONCALL',
304	'steps': [
305	$CLEANUP_ENV,
306	{
307	'name':'Build, test and collect code coverage info',
308	'shell':'$SHM $DEBUG make $PARALLELISM coverage \|\| $CONTRUN_NAME=coverage $TASK_CREATION_TOOL',
309	'user':'root',
310	$PARSER
311	},
312	],
313	$REPORT
314	}
315	]"
316
317	#
318	# RocksDB unity
319	#
320	UNITY_COMMANDS="[
321	{
322	'name':'Rocksdb Unity',
323	'oncall':'$ONCALL',
324	'steps': [
325	$CLEANUP_ENV,
326	{
327	'name':'Build, test unity test',
328	'shell':'$SHM $DEBUG V=1 make J=1 unity_test \|\| $CONTRUN_NAME=unity_test $TASK_CREATION_TOOL',
329	'user':'root',
330	$PARSER
331	},
332	],
333	$REPORT
334	}
335	]"
336
337	#
338	# Build RocksDB lite
339	#
340	LITE_BUILD_COMMANDS="[
341	{
342	'name':'Rocksdb Lite build',
343	'oncall':'$ONCALL',
344	'steps': [
345	$CLEANUP_ENV,
346	{
347	'name':'Build RocksDB debug version',
11fdf7f2	348	'shell':'$LITE make J=1 all check \|\| $CONTRUN_NAME=lite $TASK_CREATION_TOOL',
7c673cae FG	349	'user':'root',
	350	$PARSER
	351	},
	352	],
	353	$REPORT
	354	}
	355	]"
	356
	357	#
11fdf7f2 TL	358	# Report RocksDB lite binary size to scuba
11fdf7f2 TL	359	REPORT_LITE_BINARY_SIZE_COMMANDS="[
7c673cae	360	{
11fdf7f2	361	'name':'Rocksdb Lite Binary Size',
7c673cae FG	362	'oncall':'$ONCALL',
	363	'steps': [
	364	$CLEANUP_ENV,
	365	{
11fdf7f2 TL	366	'name':'Report RocksDB Lite binary size to scuba',
11fdf7f2 TL	367	'shell':'tools/report_lite_binary_size.sh',
7c673cae	368	'user':'root',
7c673cae FG	369	},
7c673cae FG	370	],
7c673cae FG	371	]"
	372
	373	#
	374	# RocksDB stress/crash test
	375	#
	376	STRESS_CRASH_TEST_COMMANDS="[
	377	{
	378	'name':'Rocksdb Stress/Crash Test',
	379	'oncall':'$ONCALL',
	380	'timeout': 86400,
	381	'steps': [
	382	$CLEANUP_ENV,
	383	{
	384	'name':'Build and run RocksDB debug stress tests',
11fdf7f2	385	'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 db_stress \|\| $CONTRUN_NAME=db_stress $TASK_CREATION_TOOL',
7c673cae FG	386	'user':'root',
	387	$PARSER
	388	},
	389	{
	390	'name':'Build and run RocksDB debug crash tests',
	391	'timeout': 86400,
11fdf7f2	392	'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 crash_test \|\| $CONTRUN_NAME=crash_test $TASK_CREATION_TOOL',
7c673cae FG	393	'user':'root',
	394	$PARSER
	395	}
	396	],
	397	$ARTIFACTS,
	398	$REPORT
	399	}
	400	]"
	401
	402	# RocksDB write stress test.
	403	# We run on disk device on purpose (i.e. no $SHM)
	404	# because we want to add some randomness to fsync commands
	405	WRITE_STRESS_COMMANDS="[
	406	{
	407	'name':'Rocksdb Write Stress Test',
	408	'oncall':'$ONCALL',
	409	'steps': [
	410	$CLEANUP_ENV,
	411	{
	412	'name':'Build and run RocksDB write stress tests',
	413	'shell':'make write_stress && python tools/write_stress_runner.py --runtime_sec=3600 --db=/tmp/rocksdb_write_stress \|\| $CONTRUN_NAME=write_stress $TASK_CREATION_TOOL',
	414	'user':'root',
	415	$PARSER
	416	}
	417	],
	418	'artifacts': [{'name': 'database', 'paths': ['/tmp/rocksdb_write_stress']}],
	419	$REPORT
	420	}
	421	]"
	422
	423
	424	#
	425	# RocksDB test under address sanitizer
	426	#
	427	ASAN_TEST_COMMANDS="[
	428	{
	429	'name':'Rocksdb Unit Test under ASAN',
	430	'oncall':'$ONCALL',
	431	'steps': [
	432	$CLEANUP_ENV,
	433	{
	434	'name':'Test RocksDB debug under ASAN',
	435	'shell':'set -o pipefail && ($SHM $ASAN $DEBUG make $PARALLELISM asan_check \|\| $CONTRUN_NAME=asan_check $TASK_CREATION_TOOL) \|& /usr/facebook/ops/scripts/asan_symbolize.py -d',
	436	'user':'root',
	437	$PARSER
	438	}
	439	],
	440	$REPORT
	441	}
	442	]"
	443
	444	#
	445	# RocksDB crash testing under address sanitizer
	446	#
	447	ASAN_CRASH_TEST_COMMANDS="[
	448	{
	449	'name':'Rocksdb crash test under ASAN',
	450	'oncall':'$ONCALL',
	451	'timeout': 86400,
	452	'steps': [
	453	$CLEANUP_ENV,
	454	{
	455	'name':'Build and run RocksDB debug asan_crash_test',
	456	'timeout': 86400,
11fdf7f2	457	'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 asan_crash_test \|\| $CONTRUN_NAME=asan_crash_test $TASK_CREATION_TOOL',
7c673cae FG	458	'user':'root',
	459	$PARSER
	460	},
	461	],
	462	$REPORT
	463	}
	464	]"
	465
	466	#
	467	# RocksDB test under undefined behavior sanitizer
	468	#
	469	UBSAN_TEST_COMMANDS="[
	470	{
	471	'name':'Rocksdb Unit Test under UBSAN',
	472	'oncall':'$ONCALL',
	473	'steps': [
	474	$CLEANUP_ENV,
	475	{
	476	'name':'Test RocksDB debug under UBSAN',
	477	'shell':'set -o pipefail && $SHM $UBSAN $DEBUG make $PARALLELISM ubsan_check \|\| $CONTRUN_NAME=ubsan_check $TASK_CREATION_TOOL',
	478	'user':'root',
	479	$PARSER
	480	}
	481	],
	482	$REPORT
	483	}
	484	]"
	485
	486	#
	487	# RocksDB crash testing under udnefined behavior sanitizer
	488	#
	489	UBSAN_CRASH_TEST_COMMANDS="[
	490	{
	491	'name':'Rocksdb crash test under UBSAN',
	492	'oncall':'$ONCALL',
	493	'timeout': 86400,
	494	'steps': [
	495	$CLEANUP_ENV,
	496	{
	497	'name':'Build and run RocksDB debug ubsan_crash_test',
	498	'timeout': 86400,
11fdf7f2	499	'shell':'$SHM $DEBUG $NON_TSAN_CRASH make J=1 ubsan_crash_test \|\| $CONTRUN_NAME=ubsan_crash_test $TASK_CREATION_TOOL',
7c673cae FG	500	'user':'root',
	501	$PARSER
	502	},
	503	],
	504	$REPORT
	505	}
	506	]"
	507
	508	#
	509	# RocksDB unit test under valgrind
	510	#
	511	VALGRIND_TEST_COMMANDS="[
	512	{
	513	'name':'Rocksdb Unit Test under valgrind',
	514	'oncall':'$ONCALL',
	515	'timeout': 86400,
	516	'steps': [
	517	$CLEANUP_ENV,
	518	{
	519	'name':'Run RocksDB debug unit tests',
	520	'timeout': 86400,
	521	'shell':'$SHM $DEBUG make $PARALLELISM valgrind_test \|\| $CONTRUN_NAME=valgrind_check $TASK_CREATION_TOOL',
	522	'user':'root',
	523	$PARSER
	524	},
	525	],
	526	$REPORT
	527	}
	528	]"
	529
	530	#
	531	# RocksDB test under TSAN
	532	#
	533	TSAN_UNIT_TEST_COMMANDS="[
	534	{
	535	'name':'Rocksdb Unit Test under TSAN',
	536	'oncall':'$ONCALL',
	537	'timeout': 86400,
	538	'steps': [
	539	$CLEANUP_ENV,
	540	{
	541	'name':'Run RocksDB debug unit test',
	542	'timeout': 86400,
	543	'shell':'set -o pipefail && $SHM $DEBUG $TSAN make $PARALLELISM check \|\| $CONTRUN_NAME=tsan_check $TASK_CREATION_TOOL',
	544	'user':'root',
	545	$PARSER
	546	},
	547	],
	548	$REPORT
	549	}
	550	]"
	551
	552	#
	553	# RocksDB crash test under TSAN
	554	#
	555	TSAN_CRASH_TEST_COMMANDS="[
	556	{
	557	'name':'Rocksdb Crash Test under TSAN',
	558	'oncall':'$ONCALL',
	559	'timeout': 86400,
	560	'steps': [
	561	$CLEANUP_ENV,
	562	{
	563	'name':'Compile and run',
564	'timeout': 86400,
11fdf7f2	565	'shell':'set -o pipefail && $SHM $DEBUG $TSAN $TSAN_CRASH CRASH_TEST_KILL_ODD=1887 make J=1 crash_test \|\| $CONTRUN_NAME=tsan_crash_test $TASK_CREATION_TOOL',
7c673cae FG	566	'user':'root',
	567	$PARSER
	568	},
	569	],
	570	$REPORT
	571	}
	572	]"
	573
	574	#
	575	# RocksDB format compatible
	576	#
	577
	578	run_format_compatible()
	579	{
	580	export TEST_TMPDIR=/dev/shm/rocksdb
	581	rm -rf /dev/shm/rocksdb
	582	mkdir /dev/shm/rocksdb
	583
11fdf7f2	584	tools/check_format_compatible.sh
7c673cae FG	585	}
	586
	587	FORMAT_COMPATIBLE_COMMANDS="[
	588	{
	589	'name':'Rocksdb Format Compatible tests',
	590	'oncall':'$ONCALL',
	591	'steps': [
	592	$CLEANUP_ENV,
	593	{
	594	'name':'Run RocksDB debug unit test',
	595	'shell':'build_tools/rocksdb-lego-determinator run_format_compatible \|\| $CONTRUN_NAME=run_format_compatible $TASK_CREATION_TOOL',
	596	'user':'root',
	597	$PARSER
	598	},
	599	],
	600	$REPORT
	601	}
	602	]"
	603
	604	#
	605	# RocksDB no compression
	606	#
	607	run_no_compression()
	608	{
	609	export TEST_TMPDIR=/dev/shm/rocksdb
	610	rm -rf /dev/shm/rocksdb
	611	mkdir /dev/shm/rocksdb
	612	make clean
	613	cat build_tools/fbcode_config.sh \| grep -iv dzlib \| grep -iv dlz4 \| grep -iv dsnappy \| grep -iv dbzip2 > .tmp.fbcode_config.sh
	614	mv .tmp.fbcode_config.sh build_tools/fbcode_config.sh
	615	cat Makefile \| grep -v tools/ldb_test.py > .tmp.Makefile
	616	mv .tmp.Makefile Makefile
	617	make $DEBUG J=1 check
	618	}
	619
	620	NO_COMPRESSION_COMMANDS="[
	621	{
	622	'name':'Rocksdb No Compression tests',
	623	'oncall':'$ONCALL',
	624	'steps': [
	625	$CLEANUP_ENV,
	626	{
	627	'name':'Run RocksDB debug unit test',
	628	'shell':'build_tools/rocksdb-lego-determinator run_no_compression \|\| $CONTRUN_NAME=run_no_compression $TASK_CREATION_TOOL',
	629	'user':'root',
	630	$PARSER
	631	},
	632	],
	633	$REPORT
	634	}
	635	]"
	636
	637	#
	638	# RocksDB regression
	639	#
	640	run_regression()
	641	{
	642	time -v bash -vx ./build_tools/regression_build_test.sh $(mktemp -d $WORKSPACE/leveldb.XXXX) $(mktemp leveldb_test_stats.XXXX)
	643
	644	# ======= report size to ODS ========
	645
	646	# parameters: $1 -- key, $2 -- value
	647	function send_size_to_ods {
	648	curl -s "https://www.intern.facebook.com/intern/agent/ods_set.php?entity=rocksdb_build&key=rocksdb.build_size.$1&value=$2" \
649	--connect-timeout 60
650	}
651
652	# === normal build ===
653	make clean
654	make -j$(nproc) static_lib
655	send_size_to_ods static_lib $(stat --printf="%s" librocksdb.a)
656	strip librocksdb.a
657	send_size_to_ods static_lib_stripped $(stat --printf="%s" librocksdb.a)
658
659	make -j$(nproc) shared_lib
660	send_size_to_ods shared_lib $(stat --printf="%s" `readlink -f librocksdb.so`)
661	strip `readlink -f librocksdb.so`
662	send_size_to_ods shared_lib_stripped $(stat --printf="%s" `readlink -f librocksdb.so`)
663
664	# === lite build ===
665	make clean
666	OPT=-DROCKSDB_LITE make -j$(nproc) static_lib
667	send_size_to_ods static_lib_lite $(stat --printf="%s" librocksdb.a)
668	strip librocksdb.a
669	send_size_to_ods static_lib_lite_stripped $(stat --printf="%s" librocksdb.a)
670
671	OPT=-DROCKSDB_LITE make -j$(nproc) shared_lib
672	send_size_to_ods shared_lib_lite $(stat --printf="%s" `readlink -f librocksdb.so`)
673	strip `readlink -f librocksdb.so`
674	send_size_to_ods shared_lib_lite_stripped $(stat --printf="%s" `readlink -f librocksdb.so`)
675	}
676
677	REGRESSION_COMMANDS="[
678	{
679	'name':'Rocksdb regression commands',
680	'oncall':'$ONCALL',
681	'steps': [
682	$CLEANUP_ENV,
683	{
684	'name':'Make and run script',
685	'shell':'build_tools/rocksdb-lego-determinator run_regression \|\| $CONTRUN_NAME=run_regression $TASK_CREATION_TOOL',
686	'user':'root',
687	$PARSER
688	},
689	],
690	$REPORT
691	}
692	]"
693
694	#
695	# RocksDB Java build
696	#
697	JAVA_BUILD_TEST_COMMANDS="[
698	{
699	'name':'Rocksdb Java Build',
700	'oncall':'$ONCALL',
701	'steps': [
702	$CLEANUP_ENV,
703	{
704	'name':'Build RocksDB for Java',
705	'shell':'$SETUP_JAVA_ENV; $SHM make rocksdbjava \|\| $CONTRUN_NAME=rocksdbjava $TASK_CREATION_TOOL',
706	'user':'root',
707	$PARSER
708	},
709	],
710	$REPORT
711	}
712	]"
713
714
715	case $1 in
7c673cae FG	716	unit)
	717	echo $UNIT_TEST_COMMANDS
	718	;;
	719	unit_non_shm)
	720	echo $UNIT_TEST_NON_SHM_COMMANDS
	721	;;
	722	release)
	723	echo $RELEASE_BUILD_COMMANDS
	724	;;
	725	unit_481)
	726	echo $UNIT_TEST_COMMANDS_481
	727	;;
	728	release_481)
	729	echo $RELEASE_BUILD_COMMANDS_481
	730	;;
	731	clang_unit)
	732	echo $CLANG_UNIT_TEST_COMMANDS
	733	;;
	734	clang_release)
	735	echo $CLANG_RELEASE_BUILD_COMMANDS
	736	;;
	737	clang_analyze)
	738	echo $CLANG_ANALYZE_COMMANDS
	739	;;
	740	code_cov)
	741	echo $CODE_COV_COMMANDS
	742	;;
	743	unity)
	744	echo $UNITY_COMMANDS
	745	;;
	746	lite)
	747	echo $LITE_BUILD_COMMANDS
	748	;;
11fdf7f2 TL	749	report_lite_binary_size)
11fdf7f2 TL	750	echo $REPORT_LITE_BINARY_SIZE_COMMANDS
7c673cae FG	751	;;
	752	stress_crash)
	753	echo $STRESS_CRASH_TEST_COMMANDS
	754	;;
	755	write_stress)
	756	echo $WRITE_STRESS_COMMANDS
	757	;;
	758	asan)
	759	echo $ASAN_TEST_COMMANDS
	760	;;
	761	asan_crash)
	762	echo $ASAN_CRASH_TEST_COMMANDS
	763	;;
	764	ubsan)
	765	echo $UBSAN_TEST_COMMANDS
	766	;;
	767	ubsan_crash)
	768	echo $UBSAN_CRASH_TEST_COMMANDS
	769	;;
	770	valgrind)
	771	echo $VALGRIND_TEST_COMMANDS
	772	;;
	773	tsan)
	774	echo $TSAN_UNIT_TEST_COMMANDS
	775	;;
	776	tsan_crash)
	777	echo $TSAN_CRASH_TEST_COMMANDS
	778	;;
	779	format_compatible)
	780	echo $FORMAT_COMPATIBLE_COMMANDS
	781	;;
	782	run_format_compatible)
	783	run_format_compatible
	784	;;
	785	no_compression)
	786	echo $NO_COMPRESSION_COMMANDS
	787	;;
	788	run_no_compression)
	789	run_no_compression
	790	;;
	791	regression)
	792	echo $REGRESSION_COMMANDS
	793	;;
	794	run_regression)
	795	run_regression
	796	;;
	797	java_build)
	798	echo $JAVA_BUILD_TEST_COMMANDS
	799	;;
	800	*)
	801	echo "Invalid determinator command"
	802	;;
	803	esac