MS-590 Refine cmake code to support cpplint

string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]" MILVUS_VERSION "${MILVUS_VERSION}")

find_package(ClangTools)

if("$ENV{CMAKE_EXPORT_COMPILE_COMMANDS}" STREQUAL "1" OR CLANG_TIDY_FOUND)

  # Generate a Clang compile_commands.json "compilation database" file for use

  # with various development tools, such as Vim's YouCompleteMe plugin.

  # See http://clang.llvm.org/docs/JSONCompilationDatabase.html

  set(CMAKE_EXPORT_COMPILE_COMMANDS 1)

endif()

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

set(BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build-support")

if(CMAKE_BUILD_TYPE STREQUAL "Release")

        OR MILVUS_VERSION_MINOR STREQUAL ""

        OR MILVUS_VERSION_PATCH STREQUAL "")

    message(WARNING "Failed to determine Milvus version from git branch name")

    set(MILVUS_VERSION "0.4.0")

    set(MILVUS_VERSION "0.5.0")

endif()

message(STATUS "Build version = ${MILVUS_VERSION}")

find_program(CPPLINT_BIN NAMES cpplint cpplint.py HINTS ${BUILD_SUPPORT_DIR})

message(STATUS "Found cpplint executable at ${CPPLINT_BIN}")

#

# "make lint" targets

#

add_custom_target(lint

                  ${PYTHON_EXECUTABLE}

                  ${BUILD_SUPPORT_DIR}/run_cpplint.py

                  ${MILVUS_LINT_QUIET})

#

# "make format" and "make check-format" targets

# "make clang-format" and "make check-clang-format" targets

#

if(${CLANG_FORMAT_FOUND})

  # runs clang format and updates files in place.

  add_custom_target(format

  add_custom_target(clang-format

                    ${PYTHON_EXECUTABLE}

                    ${BUILD_SUPPORT_DIR}/run_clang_format.py

                    --clang_format_binary

                    ${MILVUS_LINT_QUIET})

  # runs clang format and exits with a non-zero exit code if any files need to be reformatted

  add_custom_target(check-format

  add_custom_target(check-clang-format

                    ${PYTHON_EXECUTABLE}

                    ${BUILD_SUPPORT_DIR}/run_clang_format.py

                    --clang_format_binary

*cmake-build-debug*

*cmake-build-release*

*cmake_build*

*src/thirdparty*

*src/core/thirdparty*

*src/grpc*

 No newline at end of file

DB_PATH="/opt/milvus"

PROFILING="OFF"

USE_JFROG_CACHE="OFF"

RUN_CPPLINT="OFF"

CUDA_COMPILER=/usr/local/cuda/bin/nvcc

while getopts "p:d:t:uhrcgj" arg

while getopts "p:d:t:ulrcgjh" arg

do

        case $arg in

             p)

                INSTALL_PREFIX=$OPTARG

                ;;

             d)

                DB_PATH=$OPTARG

                ;;

             t)

                BUILD_TYPE=$OPTARG # BUILD_TYPE

                ;;

                echo "Build and run unittest cases" ;

                BUILD_UNITTEST="ON";

                ;;

             p)

                INSTALL_PREFIX=$OPTARG

                ;;

             d)

                DB_PATH=$OPTARG

             l)

                RUN_CPPLINT="ON"

                ;;

             r)

                if [[ -d cmake_build ]]; then

                echo "

parameter:

-t: build type(default: Debug)

-u: building unit test options(default: OFF)

-p: install prefix(default: $(pwd)/milvus)

-d: db path(default: /opt/milvus)

-t: build type(default: Debug)

-u: building unit test options(default: OFF)

-l: run cpplint, clang-format and clang-tidy(default: OFF)

-r: remove previous build directory(default: OFF)

-c: code coverage(default: OFF)

-g: profiling(default: OFF)

-j: use jfrog cache build directory

-j: use jfrog cache build directory(default: OFF)

-h: help

usage:

./build.sh -t \${BUILD_TYPE} [-u] [-h] [-g] [-r] [-c] [-k] [-j]

./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-h]

                "

                exit 0

                ;;

             ?)

                echo "unknown argument"

                echo "ERROR! unknown argument"

        exit 1

        ;;

        esac

if [[ ! -d cmake_build ]]; then

    mkdir cmake_build

	MAKE_CLEAN="ON"

fi

cd cmake_build

CUDA_COMPILER=/usr/local/cuda/bin/nvcc

if [[ ${MAKE_CLEAN} == "ON" ]]; then

    CMAKE_CMD="cmake -DBUILD_UNIT_TEST=${BUILD_UNITTEST} \

CMAKE_CMD="cmake \

-DBUILD_UNIT_TEST=${BUILD_UNITTEST} \

-DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}

-DCMAKE_BUILD_TYPE=${BUILD_TYPE} \

-DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \

-DMILVUS_DB_PATH=${DB_PATH} \

-DMILVUS_ENABLE_PROFILING=${PROFILING} \

-DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \

    -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \

../"

echo ${CMAKE_CMD}

${CMAKE_CMD}

if [[ ${MAKE_CLEAN} == "ON" ]]; then

    make clean

fi

if [[ ${RUN_CPPLINT} == "ON" ]]; then

    # cpplint check

    make lint

    if [ $? -ne 0 ]; then

        echo "ERROR! cpplint check not pass"

        exit 1

    fi

    # clang-format check

    make check-clang-format

    if [ $? -ne 0 ]; then

        echo "ERROR! clang-format check failed"

        exit 1

    fi

    # clang-tidy check

    make check-clang-tidy

    if [ $? -ne 0 ]; then

        echo "ERROR! clang-tidy check failed"

        exit 1

    fi

else

    # compile and build

    make -j 4 || exit 1

    # strip binary symbol

    if [[ ${BUILD_TYPE} != "Debug" ]]; then

        strip src/milvus_server

    fi

    make install || exit 1

    # evaluate code coverage

    if [[ ${BUILD_COVERAGE} == "ON" ]]; then

        cd -

        bash `pwd`/coverage.sh

        cd -

    fi

fi

 No newline at end of file

#----------------------------------------------------------------------

set_option_category("Test and benchmark")

unset(MILVUS_BUILD_TESTS CACHE)

if (BUILD_UNIT_TEST)

    define_option(MILVUS_BUILD_TESTS "Build the MILVUS googletest unit tests" ON)

else()