yoloserv/modules/openvino-master/.ci/azure/linux_debian.yml

trigger:
  branches:
    include:
    - 'master'
    - 'releases/*'
  paths:
    exclude:
    - '*/docs/*'
    - 'docs/*'
    - '*/*.md'
    - '*.md'
    - '*/layer_tests_summary/*'
    - '*/conformance/*'
    - 'tests/layer_tests/*'

pr:
  branches:
    include:
    - 'master'
    - 'releases/*'
  paths:
    exclude:
    - '*/docs/*'
    - 'docs/*'
    - '*/*.md'
    - '*.md'
    - '*/layer_tests_summary/*'
    - '*/conformance/*'
    - 'tests/layer_tests/*'

resources:
  repositories:
  - repository: testdata
    type: github
    endpoint: openvinotoolkit
    name: openvinotoolkit/testdata
    ref: master

jobs:
- job: Lin_Debian
  # About 150% of total time
  timeoutInMinutes: '120'

  pool:
    name: LIN_VMSS_VENV_F16S_U20_WU2

  variables:
    system.debug: true
    VSTS_HTTP_RETRY: 5
    VSTS_HTTP_TIMEOUT: 200
    BUILD_TYPE: Release
    REPO_DIR: $(Build.Repository.LocalPath)
    MODELS_PATH: $(REPO_DIR)/../testdata
    WORK_DIR: $(Pipeline.Workspace)/_w
    BUILD_DIR: $(WORK_DIR)/build
    BUILD_SAMPLES_DIR: $(WORK_DIR)/build_samples
    BUILD_LAYER_TESTS_DIR: $(WORK_DIR)/build_layer_tests
    BUILD_SAMPLES_TESTS_DIR: $(WORK_DIR)/build_samples_tests
    INSTALL_DIR: $(WORK_DIR)/install_pkg
    INSTALL_TEST_DIR: $(INSTALL_DIR)/tests
    LAYER_TESTS_DIR: $(INSTALL_TEST_DIR)/layer_tests
    SAMPLES_INSTALL_DIR: /usr/share/openvino/samples
    PYTHON_SAMPLES_INSTALL_DIR: $(INSTALL_DIR)/share/openvino/samples/python
    PYTHON_WHEEL_INSTALL_DIR: $HOME/.local/lib/python3.8/site-packages
    BUILD_VENV: $(WORK_DIR)/build_venv
    TEST_VENV: $(WORK_DIR)/test_venv
    TMP_DIR: /mnt/tmp
    SHARE_DIR: /mount/cinfsshare/onnxtestdata
    CCACHE_DIR: $(SHARE_DIR)/ccache/master/linux

  steps:
  - script: |
      curl -H Metadata:true --noproxy "*" "http://169.254.169.254/metadata/instance?api-version=2019-06-01"
      whoami
      uname -a
      echo Python3 info ; which python3 ; python3 --version
      echo Python info ; which python ; python --version
      echo gcc info ; which gcc ; gcc --version
      echo cmake info ; which cmake ; cmake --version
      lsb_release
      env
      cat /proc/cpuinfo
      cat /proc/meminfo
      cat /etc/fstab
      vmstat -s
      df
      lsblk -o NAME,HCTL,SIZE,MOUNTPOINT | grep -i "sd"
      free -h
      echo TargetBranch: $(System.PullRequest.TargetBranch)
      echo SourceBranch: $(Build.SourceBranch)      
    displayName: 'System info'

  - script: |
      set -e
      rm -rf $(WORK_DIR) ; mkdir $(WORK_DIR)
      rm -rf $(BUILD_DIR) ; mkdir $(BUILD_DIR)
      rm -rf $(BUILD_SAMPLES_DIR) ; mkdir $(BUILD_SAMPLES_DIR)
      sudo rm -rf $(TMP_DIR) ; sudo mkdir $(TMP_DIR) ; sudo chmod 777 -R $(TMP_DIR)
      sudo mkdir -p $(SHARE_DIR)
      sudo apt --assume-yes update && sudo apt --assume-yes install nfs-common
      sudo mount -vvv -t nfs cinfsshare.file.core.windows.net:/cinfsshare/onnxtestdata $(SHARE_DIR) -o vers=4,minorversion=1,sec=sys
      mkdir -p $(CCACHE_DIR)      
    displayName: 'Make dir'

  - checkout: self
    clean: 'true'
    submodules: 'true'
    path: openvino

  - script: |
      set -e
      sudo -E $(REPO_DIR)/install_build_dependencies.sh
      # 'clang' is used as a default compiler
      sudo apt --assume-yes install clang
      sudo apt --assume-yes install --no-install-recommends libopencv-imgproc-dev libopencv-imgcodecs-dev
      # install build dependencies
      (cd $(WORK_DIR) && python3 -m venv build_venv)
      $(BUILD_VENV)/bin/python3 -m pip install -U pip
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/bindings/python/wheel/requirements-dev.txt
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/bindings/python/requirements.txt
      # For running Python API tests
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/bindings/python/src/compatibility/openvino/requirements-dev.txt
      # For running Paddle frontend unit tests
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/frontends/paddle/tests/requirements.txt
      # For running ONNX frontend unit tests
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/frontends/onnx/tests/requirements.txt
      # For running TensorFlow frontend unit tests
      $(BUILD_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/frontends/tensorflow/tests/requirements.txt
      # For MO unit tests
      (cd $(WORK_DIR) && python3 -m venv test_venv)
      $(TEST_VENV)/bin/python3 -m pip install -U pip
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_mxnet.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_caffe.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_kaldi.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_onnx.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_tf2.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements_dev.txt
      $(TEST_VENV)/bin/python3 -m pip install -r $(REPO_DIR)/src/frontends/paddle/tests/requirements.txt
      # for Python API tests
      /usr/bin/python3 -m pip install -r $(REPO_DIR)/src/bindings/python/requirements_test.txt
      /usr/bin/python3 -m pip install -r $(REPO_DIR)/tools/mo/requirements.txt
      /usr/bin/python3 -m pip uninstall -y numpy # apt-get install python3-numpy will be used
      # Speed up build
      sudo apt -y --no-install-recommends install unzip
      wget https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-linux.zip
      unzip ninja-linux.zip
      sudo cp -v ninja /usr/local/bin/
      # Speed up tests
      git clone https://github.com/google/gtest-parallel.git      
    displayName: 'Install build dependencies'

    # Should be after 'Install dependencies' because Git lfs is not installed
  - checkout: testdata
    clean: 'true'
    lfs: 'true'
    path: testdata

  - task: CMake@1
    inputs:
      # CMake must get Python 3.x version by default
      cmakeArgs: >
        -GNinja
        -DENABLE_CPPLINT=OFF
        -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
        -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
        -DENABLE_PYTHON=ON
        -DENABLE_INTEL_GNA=OFF
        -DPYTHON_EXECUTABLE=$(BUILD_VENV)/bin/python3
        -DENABLE_TESTS=ON
        -DENABLE_FASTER_BUILD=ON
        -DENABLE_STRICT_DEPENDENCIES=OFF
        -DENABLE_SYSTEM_SNAPPY=ON
        -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
        -DCMAKE_C_COMPILER_LAUNCHER=ccache
        -DCMAKE_CXX_LINKER_LAUNCHER=ccache
        -DCMAKE_C_LINKER_LAUNCHER=ccache
        -DENABLE_PYTHON_PACKAGING=ON
        -DCPACK_GENERATOR=DEB
        -S $(REPO_DIR)
        -B $(BUILD_DIR)        
    displayName: 'CMake OpenVINO'

  - script: ls -alR $(REPO_DIR)/temp/
    displayName: 'List temp SDKs'

  - script: ccache --zero-stats --max-size=50G --show-config
    displayName: 'Clean ccache stats'

  - script: cmake --build $(BUILD_DIR) --parallel --config $(BUILD_TYPE)
    env:
      CCACHE_DIR: $(CCACHE_DIR)
      CCACHE_TEMPDIR: $(TMP_DIR)/ccache
      CCACHE_BASEDIR: $(Pipeline.Workspace)
      CCACHE_MAXSIZE: 50G
    displayName: 'Build Lin'

  - script: ccache --show-stats
    displayName: 'Show ccache stats'

  - script: ls -alR $(REPO_DIR)/bin/
    displayName: 'List bin files'

  - task: CMake@1
    inputs:
      cmakeArgs: >
        -GNinja
        -S $(REPO_DIR)/tests/layer_tests
        -B $(BUILD_LAYER_TESTS_DIR)        
    displayName: 'CMake Layer Tests'

  - script: cmake --build $(BUILD_LAYER_TESTS_DIR) --parallel --config $(BUILD_TYPE)
    displayName: 'Build Layer Tests'

    # to check that wheel packages tested later, contain all all the dependencies like TBB or pugixml
  - script: sudo apt-get remove libtbb2 libpugixml1v5 -y
    displayName: 'Remove debian dependencies'

  - script: cmake -DCOMPONENT=python_wheels -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_DIR)/cmake_install.cmake
    displayName: 'Install wheel packages'

  - script: cmake -DCOMPONENT=python_samples -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_DIR)/cmake_install.cmake
    displayName: 'Install Python Samples'

  - script: cmake -DCOMPONENT=tests -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_LAYER_TESTS_DIR)/cmake_install.cmake
    displayName: 'Install Layer Tests'

  - script: cmake -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -DCOMPONENT=tests -P $(BUILD_DIR)/cmake_install.cmake
    displayName: 'Install tests'

  - script: ls -alR $(INSTALL_DIR)
    displayName: 'List install test files'

  - script: |
      sudo apt-get install libtbb-dev libpugixml-dev -y
      cmake --build $(BUILD_DIR) --config $(BUILD_TYPE) --target package --parallel      
    displayName: 'Build Debian packages'

  - script: |
      set -e
      # install debian packages from previous release
      sudo apt-get -y update
      sudo apt-get install --no-install-recommends gnupg wget -y
      wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB
      sudo apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB
      echo "deb https://apt.repos.intel.com/openvino/2023 ubuntu20 main" | sudo tee /etc/apt/sources.list.d/intel-openvino-2023.list
      sudo apt-get update -o Dir::Etc::sourcelist=/etc/apt/sources.list.d/intel-openvino-2023.list
      sudo apt-get install openvino -y
      # install our local one and make sure the conflicts are resolved
      sudo apt-get install --no-install-recommends dpkg-dev -y
      rm -r _CPack_Packages
      dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz
      echo "deb [trusted=yes] file:$(BUILD_DIR) ./" | sudo tee /etc/apt/sources.list.d/openvino-local.list
      sudo apt-get update
      sudo apt-get install openvino -y      
    workingDirectory: $(BUILD_DIR)
    displayName: 'Install Debian packages'

  - script: ls -alR $(INSTALL_DIR)
    displayName: 'List install files'

  - script: rm -fr $(BUILD_DIR)
    displayName: 'Clean build dir'

  - script: $(SAMPLES_INSTALL_DIR)/cpp/build_samples.sh -i $(INSTALL_DIR)
    displayName: 'Build cpp samples - gcc'

  - script: $(SAMPLES_INSTALL_DIR)/cpp/build_samples.sh -i $(INSTALL_DIR)
    displayName: 'Build cpp samples - clang'
    env:
      CC: clang
      CXX: clang++

  - script: $(SAMPLES_INSTALL_DIR)/c/build_samples.sh -i $(INSTALL_DIR)
    displayName: 'Build c samples'

  - script: $(INSTALL_TEST_DIR)/ov_core_unit_tests --gtest_print_time=1 --gtest_filter=-*IE_GPU* --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-NGraphUT.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'OV Core UT'

  - script: |
      $(INSTALL_TEST_DIR)/ov_proxy_plugin_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-OVProxyTests.xml      
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'OV Proxy Tests'

  - script: |
      $(INSTALL_TEST_DIR)/ov_hetero_func_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-OVHeteroFuncTests.xml      
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'OV Hetero Func Tests'

  - script: $(INSTALL_TEST_DIR)/ov_onnx_frontend_tests --gtest_print_time=1 --gtest_filter=-*IE_GPU* --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ONNXFrontend.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'ONNX Frontend Tests'

  # TODO Reenable PDPD after paddlepaddle==2.5.0 with compliant protobuf is released (ticket 95904)
  - script: $(INSTALL_TEST_DIR)/paddle_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-Paddle.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'Paddle Frontend UT'
    enabled: 'false'

  - script: $(INSTALL_TEST_DIR)/ov_tensorflow_frontend_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-Tensorflow.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'TensorFlow Frontend Unit Tests'

  - script: $(INSTALL_TEST_DIR)/ov_tensorflow_common_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-TensorflowCommon.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'TensorFlow Common Unit Tests'

  - script: $(INSTALL_TEST_DIR)/ov_tensorflow_lite_frontend_tests --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-TensorflowLite.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'TensorFlow Lite Frontend Unit Tests'

  - script: $(INSTALL_TEST_DIR)/ov_snippets_func_tests --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ov_snippets_func_tests.xml
    displayName: 'Snippets Func Tests'

  - script: $(INSTALL_TEST_DIR)/ov_cpu_unit_tests --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ov_cpu_unit_tests.xml
    displayName: 'Intel CPU Unit Tests'

  - script: $(INSTALL_TEST_DIR)/ov_auto_unit_tests --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ov_auto_unit_tests.xml
    displayName: 'AUTO UT'

  - script: $(INSTALL_TEST_DIR)/ov_template_func_tests --gtest_filter=*smoke* --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-templateFuncTests.xml
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'TEMPLATE FuncTests'

  - script: $(INSTALL_TEST_DIR)/InferenceEngineCAPITests --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-InferenceEngineCAPITests.xml
    env:
      DATA_PATH: $(MODELS_PATH)
      MODELS_PATH: $(MODELS_PATH)
    displayName: 'IE CAPITests'

  - script: $(INSTALL_TEST_DIR)/ov_capi_test --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ov_capi_test.xml
    env:
      DATA_PATH: $(MODELS_PATH)
      MODELS_PATH: $(MODELS_PATH)
    displayName: 'OV CAPITests'

    # Skip test_onnx/test_zoo_models and test_onnx/test_backend due to long execution time
  - script: |
      /usr/bin/python3 -m pytest -s $(INSTALL_TEST_DIR)/pyngraph \
        --junitxml=$(INSTALL_TEST_DIR)/TEST-Pyngraph.xml \
        --ignore=$(INSTALL_TEST_DIR)/pyngraph/tests/test_onnx/test_zoo_models.py \
        --ignore=$(INSTALL_TEST_DIR)/pyngraph/tests/test_onnx/test_backend.py      
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
    displayName: 'nGraph and IE Python Bindings Tests'

  - script: |
      /usr/bin/python3 -m pytest -s $(INSTALL_TEST_DIR)/pyopenvino \
        --junitxml=$(INSTALL_TEST_DIR)/TEST-Pyngraph.xml \
        --ignore=$(INSTALL_TEST_DIR)/pyopenvino/tests/test_utils/test_utils.py -v      
    env:
      # Required by python imports to load requires libraries
      # - tests install dir for mock_py
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
      # For python imports to import pybind_mock_frontend
      PYTHONPATH: $(INSTALL_TEST_DIR):$(REPO_DIR)/tools/mo/
    displayName: 'Python API 2.0 Tests'

  # Skip test_onnx/test_zoo_models and test_onnx/test_backend due to long execution time
  - script: |
      /usr/bin/python3 -m pytest -s $(REPO_DIR)/src/frontends/onnx/tests \
        --ignore=$(REPO_DIR)/src/frontends/onnx/tests/test_python/test_zoo_models.py \
        --ignore=$(REPO_DIR)/src/frontends/onnx/tests/test_python/test_backend.py -v      
    env:
      LD_LIBRARY_PATH: $(INSTALL_TEST_DIR)
      PYTHONPATH: $(INSTALL_TEST_DIR)
    displayName: 'ONNX Frontend Python Tests' 

  - script: |
      set -e
      # TODO: fix 'No mock frontend API available'
      $(TEST_VENV)/bin/python3 -m pip install openvino-dev --find-links=$(INSTALL_DIR)/tools
      $(TEST_VENV)/bin/python3 -m pytest -s $(INSTALL_TEST_DIR)/mo/unit_tests --junitxml=$(INSTALL_TEST_DIR)/TEST-ModelOptimizer.xml      
    env:
      PYTHONPATH: $(REPO_DIR)/tools/ovc/
    displayName: 'Model Optimizer UT'

  # run not all smoke filter to save time in post-commit
  - script: $(INSTALL_TEST_DIR)/ov_cpu_func_tests --gtest_filter=*OVCLass*:*CoreThreadingTests* --gtest_print_time=1 --gtest_output=xml:$(INSTALL_TEST_DIR)/TEST-ov_cpu_func_tests.xml
    displayName: 'CPU FuncTests'

  - task: CMake@1
    inputs:
      cmakeArgs: >
        -GNinja
        -S $(REPO_DIR)/tests/samples_tests
        -B $(BUILD_SAMPLES_TESTS_DIR)        
    displayName: 'CMake Samples Tests'

  - script: cmake -DCOMPONENT=tests -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -P $(BUILD_SAMPLES_TESTS_DIR)/cmake_install.cmake
    displayName: 'Install Samples Tests'

  - script: |
      set -e
      /usr/bin/python3 -m pip install -r $(INSTALL_TEST_DIR)/smoke_tests/requirements.txt
      # GNA isn't a part of Debian package, so filter out that tests
      /usr/bin/python3 -m pytest $(INSTALL_TEST_DIR)/smoke_tests/ -k "not GNA" --env_conf $(INSTALL_TEST_DIR)/smoke_tests/env_config.yml -s --junitxml=$(INSTALL_TEST_DIR)/TEST-SamplesSmokeTests.xml      
    env:
      IE_APP_PATH: $(INSTALL_DIR)/samples_bin
      LD_LIBRARY_PATH: $(INSTALL_DIR)/samples_bin
      IE_APP_PYTHON_PATH: $(PYTHON_SAMPLES_INSTALL_DIR)/
      SHARE: $(INSTALL_TEST_DIR)/smoke_tests/samples_smoke_tests_data/
      WORKSPACE: $(INSTALL_DIR)
    displayName: 'Samples Smoke Tests'

  - script: |
      set -e
      $(TEST_VENV)/bin/python3 -m pip install -r $(LAYER_TESTS_DIR)/requirements.txt
      $(TEST_VENV)/bin/python3 -m pytest $(LAYER_TESTS_DIR)/tensorflow_tests/test_tf_Roll.py --ir_version=10 --junitxml=$(INSTALL_TEST_DIR)/TEST-tf_Roll.xmlTEST      
    env:
      PYTHONPATH: $(REPO_DIR)/tools/ovc/:$(LAYER_TESTS_DIR)
    displayName: 'TensorFlow 1 Layer Tests - Legacy FE'

  - script: |
      set -e
      $(TEST_VENV)/bin/python3 -m pip install -r $(LAYER_TESTS_DIR)/requirements.txt
      $(RUN_PREFIX) $(TEST_VENV)/bin/python3 -m pytest $(LAYER_TESTS_DIR)/tensorflow_lite_tests/ --junitxml=$(INSTALL_TEST_DIR)/TEST-tfl_fe.xmlTEST      
    env:
      PYTHONPATH: $(REPO_DIR)/tools/ovc/:$(REPO_DIR)/tools/mo/:$(LAYER_TESTS_DIR)
      TEST_DEVICE: CPU
    displayName: 'TensorFlow Lite Layer Tests - TFL FE'

  - task: PublishTestResults@2
    condition: always()
    inputs:
      testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit, cTest
      testResultsFiles: '**/TEST-*.xml'
      #searchFolder: '$(BUILD_DIR)'
      mergeTestResults: false # Optional
      #failTaskOnFailedTests: false # Optional
      #testRunTitle: 'Pre/Post-Commit' # Optional
      buildPlatform: 'x64' # Optional
      buildConfiguration: 'Linux' # Optional
      #publishRunAttachments: true # Optional