text: #
  # Copyright(c) 2019-2020 Intel Corporation
  # SPDX-License-Identifier: BSD-3-Clause-Clear
  #
  
  import wget
  import os
  from enum import Enum
  
  from core.test_run import TestRun
  from test_tools import fs_utils
  from test_utils.os_utils import DEBUGFS_MOUNT_POINT
  
  
  KEDR_0_6_URL = "https://github.com/euspectre/kedr/archive/v0.6.tar.gz"
  BUILD_DIR = "build"
  LEAKS_LOGS_PATH = f"{DEBUGFS_MOUNT_POINT}/kedr_leak_check"
  KMALLOC_FAULT_SIMULATION_PATH = "/sys/kernel/debug/kedr_fault_simulation"
  
  
  class KedrProfile(Enum):
      MEM_LEAK_CHECK = "leak_check.conf"
      FAULT_SIM = "fsim.conf"
  
  
  class Kedr:
      @staticmethod
      def is_installed():
          return "KEDR version" in TestRun.executor.run("kedr --version").stdout.strip()
  
      @classmethod
      def install(cls):
          if cls.is_installed():
              TestRun.LOGGER.info("Kedr is already installed!")
              return
  
          # TODO check if cmake is installed before
          # TODO consider using os_utils.download_file()
          kedr_archive = wget.download(KEDR_0_6_URL)
  
          TestRun.executor.rsync_to(
              f"\"{kedr_archive}\"",
              f"{TestRun.config['working_dir']}")
  
          kedr_dir = TestRun.executor.run_expect_success(
              f"cd {TestRun.config['working_dir']} && "
              f"tar -ztf \"{kedr_archive}\" | sed -e 's@/.*@@' | uniq"
          ).stdout
  
          TestRun.executor.run_expect_success(
              f"cd {TestRun.config['working_dir']} && "
              f"tar -xf \"{kedr_archive}\" && "
              f"cd {kedr_dir} && "
              f"mkdir -p {BUILD_DIR} && "
              f"cd {BUILD_DIR} && "
              f"cmake ../sources/ && "
              f"make && "
              f"make install"
          )
  
          os.remove(kedr_archive)
          TestRun.LOGGER.info("Kedr installed succesfully")
  
      @classmethod
      def is_loaded(cls):
          if not cls.is_installed():
              raise Exception("Kedr is not installed!")
  
          if "KEDR status: loaded" in TestRun.executor.run_expect_success("kedr status").stdout:
              return True
          else:
              return False
  
      @classmethod
      def start(cls, module, profile: KedrProfile = KedrProfile.MEM_LEAK_CHECK):
          if not cls.is_installed():
              raise Exception("Kedr is not installed!")
  
          TestRun.LOGGER.info(f"Starting kedr with {profile} profile")
          start_cmd = f"kedr start {module} -f {profile.value}"
          TestRun.executor.run_expect_success(start_cmd)
  
      # TODO extend to scenarios other than kmalloc
      def setup_fault_injections(condition: str = "1"):
          TestRun.executor.run_expect_success(
              f'echo "kmalloc" > {KMALLOC_FAULT_SIMULATION_PATH}/points/kmalloc/current_indicator')
          TestRun.executor.run_expect_success(
              f'echo "{condition}" > {KMALLOC_FAULT_SIMULATION_PATH}/points/kmalloc/expression')
  
      @classmethod
      def fsim_show_last_fault(cls):
          if not cls.is_installed():
              raise Exception("Kedr is not installed!")
  
          if not cls.is_loaded():
              raise Exception("Kedr is not loaded!")
  
          return fs_utils.read_file(f"{KMALLOC_FAULT_SIMULATION_PATH}/last_fault")
  
      @classmethod
      def stop(cls):
          if not cls.is_installed():
              raise Exception("Kedr is not installed!")
  
          TestRun.executor.run_expect_success("kedr stop")
  
      @classmethod
      def check_for_mem_leaks(cls, module):
          if not cls.is_installed():
              raise Exception("Kedr is not installed!")
  
          if not cls.is_loaded():
              raise Exception("Kedr is not loaded!")
  
          if fs_utils.check_if_directory_exists(f"{LEAKS_LOGS_PATH}/{module}"):
              logs_path = f"{LEAKS_LOGS_PATH}/{module}"
          elif fs_utils.check_if_directory_exists(f"{DEBUGFS_MOUNT_POINT}"):
              logs_path = f"{LEAKS_LOGS_PATH}"
          else:
              raise Exception("Couldn't find kedr logs dir!")
  
          leaks = fs_utils.read_file(f"{logs_path}/possible_leaks")
          frees = fs_utils.read_file(f"{logs_path}/unallocated_frees")
          summary = fs_utils.read_file(f"{logs_path}/info")
          if leaks or frees:
              raise Exception("Memory leaks found!\n"
                              f"Kedr summary: {summary}\n"
                              f"Possible memory leaks: {leaks}\n"
                              f"Unallocated frees: {frees}\n")
  