#!/usr/bin/env python
"""
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Ambari Agent

"""

import os
import re
import subprocess
import socket
import getpass
import tempfile

from resource_management.libraries.functions import packages_analyzer
from resource_management.libraries.functions.default import default
from ambari_commons import os_utils
from ambari_commons.os_check import OSCheck, OSConst
from ambari_commons.inet_utils import download_file
from resource_management import Script, Execute, format
from ambari_agent.HostInfo import HostInfo
from ambari_agent.HostCheckReportFileHandler import HostCheckReportFileHandler
from resource_management.core.resources import Directory, File
from resource_management.core.exceptions import Fail
from ambari_commons.constants import AMBARI_SUDO_BINARY
from resource_management.core import shell
from resource_management.core.logger import Logger

# WARNING. If you are adding a new host check that is used by cleanup, add it to BEFORE_CLEANUP_HOST_CHECKS
# It is used by HostCleanup.py
CHECK_JAVA_HOME = "java_home_check"
CHECK_DB_CONNECTION = "db_connection_check"
CHECK_HOST_RESOLUTION = "host_resolution_check"
CHECK_LAST_AGENT_ENV = "last_agent_env_check"
CHECK_INSTALLED_PACKAGES = "installed_packages"
CHECK_EXISTING_REPOS = "existing_repos"
CHECK_TRANSPARENT_HUGE_PAGE = "transparentHugePage"

BEFORE_CLEANUP_HOST_CHECKS = ','.join([CHECK_LAST_AGENT_ENV, CHECK_INSTALLED_PACKAGES, CHECK_EXISTING_REPOS, CHECK_TRANSPARENT_HUGE_PAGE])

# If exit_code for some of these checks is not 0 task will be failed
FALLIBLE_CHECKS = [CHECK_DB_CONNECTION]

DB_MYSQL = "mysql"
DB_ORACLE = "oracle"
DB_POSTGRESQL = "postgres"
DB_MSSQL = "mssql"
DB_SQLA = "sqlanywhere"

JDBC_DRIVER_CLASS_MYSQL = "com.mysql.jdbc.Driver"
JDBC_DRIVER_CLASS_ORACLE = "oracle.jdbc.driver.OracleDriver"
JDBC_DRIVER_CLASS_POSTGRESQL = "org.postgresql.Driver"
JDBC_DRIVER_CLASS_MSSQL = "com.microsoft.sqlserver.jdbc.SQLServerDriver"
JDBC_DRIVER_CLASS_SQLA = "sap.jdbc4.sqlanywhere.IDriver"

JDBC_AUTH_SYMLINK_MSSQL = "sqljdbc_auth.dll"

JDBC_DRIVER_SQLA_JAR = "sajdbc4.jar"
JARS_PATH_IN_ARCHIVE_SQLA = "/sqla-client-jdbc/java"
LIBS_PATH_IN_ARCHIVE_SQLA = "/sqla-client-jdbc/native/lib64"
JDBC_DRIVER_SQLA_JAR_PATH_IN_ARCHIVE = "/sqla-client-jdbc/java/" + JDBC_DRIVER_SQLA_JAR

THP_FILE_REDHAT = "/sys/kernel/mm/redhat_transparent_hugepage/enabled"
THP_FILE_UBUNTU = "/sys/kernel/mm/transparent_hugepage/enabled"

class CheckHost(Script):
  # Package prefixes that are used to find repos (then repos are used to find other packages)
  PACKAGES = [
    "^hadoop.*$", "^zookeeper.*$", "^webhcat.*$", "^oozie.*$", "^ambari.*$", "^.+-manager-server-db.*$",
    "^.+-manager-daemons.*$", "^mahout[_\-]\d.*$", "^spark.*$", "^falcon.*$", "^hbase.*$", "^kafka.*$", "^knox.*$",
    "^slider.*$", "^sqoop.*$", "^storm.*$", "^flume.*$","^hcatalog.*$", "^phoenix.*$", "^ranger.*$", "^accumulo.*$", "^hive_.*$",
    "^pig[_\-.].*$" # there's a default 'pigz' package which we should avoid
  ]
  

  # ignore packages from repos whose names start with these strings
  IGNORE_PACKAGES_FROM_REPOS = [
    "installed"
  ]
  

  # ignore required packages
  IGNORE_PACKAGES = [
    "epel-release", "ambari-server", "ambari-agent", "nagios",
    # ganglia related:
    "ganglia", "libganglia", "libconfuse", "perl", "rrdtool", "python-rrdtool", "gmetad", "librrd", "rrdcached"
  ]
  
  # Additional packages to look for (search packages that start with these)
  ADDITIONAL_PACKAGES = [
    "ambari-log4j"
  ]
  
  # ignore repos from the list of repos to be cleaned
  IGNORE_REPOS = [
    "HDP-UTILS", "AMBARI", "BASE", "EXTRAS"
  ]
  
  def __init__(self):
    self.reportFileHandler = HostCheckReportFileHandler()
  
  def actionexecute(self, env):
    Logger.info("Host checks started.")
    config = Script.get_config()
    tmp_dir = Script.get_tmp_dir()
    report_file_handler_dict = {}

    #print "CONFIG: " + str(config)

    check_execute_list = config['commandParams']['check_execute_list']
    if check_execute_list == '*BEFORE_CLEANUP_HOST_CHECKS*':
      check_execute_list = BEFORE_CLEANUP_HOST_CHECKS
    structured_output = {}

    Logger.info("Check execute list: " + str(check_execute_list))

    # check each of the commands; if an unknown exception wasn't handled
    # by the functions, then produce a generic exit_code : 1
    if CHECK_JAVA_HOME in check_execute_list:
      try :
        java_home_check_structured_output = self.execute_java_home_available_check(config)
        structured_output[CHECK_JAVA_HOME] = java_home_check_structured_output
      except Exception, exception:
        Logger.exception("There was an unexpected error while checking for the Java home location: " + str(exception))
        structured_output[CHECK_JAVA_HOME] = {"exit_code" : 1, "message": str(exception)}

    if CHECK_DB_CONNECTION in check_execute_list:
      try :
        db_connection_check_structured_output = self.execute_db_connection_check(config, tmp_dir)
        structured_output[CHECK_DB_CONNECTION] = db_connection_check_structured_output
      except Exception, exception:
        Logger.exception("There was an unknown error while checking database connectivity: " + str(exception))
        structured_output[CHECK_DB_CONNECTION] = {"exit_code" : 1, "message": str(exception)}

    if CHECK_HOST_RESOLUTION in check_execute_list:
      try :
        host_resolution_structured_output = self.execute_host_resolution_check(config)
        structured_output[CHECK_HOST_RESOLUTION] = host_resolution_structured_output
      except Exception, exception :
        Logger.exception("There was an unknown error while checking IP address lookups: " + str(exception))
        structured_output[CHECK_HOST_RESOLUTION] = {"exit_code" : 1, "message": str(exception)}
    if CHECK_LAST_AGENT_ENV in check_execute_list:
      try :
        last_agent_env_structured_output = self.execute_last_agent_env_check()
        structured_output[CHECK_LAST_AGENT_ENV] = last_agent_env_structured_output
      except Exception, exception :
        Logger.exception("There was an unknown error while checking last host environment details: " + str(exception))
        structured_output[CHECK_LAST_AGENT_ENV] = {"exit_code" : 1, "message": str(exception)}
        
    # CHECK_INSTALLED_PACKAGES and CHECK_EXISTING_REPOS required to run together for
    # reasons of not doing the same common work twice for them as it takes some time, especially on Ubuntu.
    if CHECK_INSTALLED_PACKAGES in check_execute_list and CHECK_EXISTING_REPOS in check_execute_list:
      try :
        installed_packages, repos = self.execute_existing_repos_and_installed_packages_check(config)
        structured_output[CHECK_INSTALLED_PACKAGES] = installed_packages
        structured_output[CHECK_EXISTING_REPOS] = repos
      except Exception, exception :
        Logger.exception("There was an unknown error while checking installed packages and existing repositories: " + str(exception))
        structured_output[CHECK_INSTALLED_PACKAGES] = {"exit_code" : 1, "message": str(exception)}
        structured_output[CHECK_EXISTING_REPOS] = {"exit_code" : 1, "message": str(exception)}

    # Here we are checking transparent huge page if CHECK_TRANSPARENT_HUGE_PAGE is in check_execute_list
    if CHECK_TRANSPARENT_HUGE_PAGE in check_execute_list:
      try :
        transparent_huge_page_structured_output = self.execute_transparent_huge_page_check(config)
        structured_output[CHECK_TRANSPARENT_HUGE_PAGE] = transparent_huge_page_structured_output
      except Exception, exception :
        Logger.exception("There was an unknown error while getting transparent huge page data: " + str(exception))
        structured_output[CHECK_TRANSPARENT_HUGE_PAGE] = {"exit_code" : 1, "message": str(exception)}

    # this is necessary for HostCleanup to know later what were the results.
    self.reportFileHandler.writeHostChecksCustomActionsFile(structured_output)
    
    self.put_structured_out(structured_output)

    error_message = ""
    for check_name in FALLIBLE_CHECKS:
      if check_name in structured_output and "exit_code" in structured_output[check_name] \
          and structured_output[check_name]["exit_code"] != 0:
        error_message += "Check {0} was unsuccessful. Exit code: {1}.".format(check_name, \
                                                                             structured_output[check_name]["exit_code"])
        if "message" in structured_output[check_name]:
          error_message += " Message: {0}".format(structured_output[check_name]["message"])
        error_message += "\n"

    Logger.info("Host checks completed.")
    Logger.debug("Structured output: " + str(structured_output))

    if error_message:
      Logger.error(error_message)
      raise Fail(error_message)


  def execute_transparent_huge_page_check(self, config):
    Logger.info("Transparent huge page check started.")

    thp_regex = "\[(.+)\]"
    file_name = None
    if OSCheck.is_ubuntu_family():
      file_name = THP_FILE_UBUNTU
    elif OSCheck.is_redhat_family():
      file_name = THP_FILE_REDHAT
    if file_name and os.path.isfile(file_name):
      with open(file_name) as f:
        file_content = f.read()
        transparent_huge_page_check_structured_output = {"exit_code" : 0, "message": str(re.search(thp_regex,
                                                                                                    file_content).groups()[0])}
    else:
      transparent_huge_page_check_structured_output = {"exit_code" : 0, "message": ""}

    Logger.info("Transparent huge page check completed.")
    return transparent_huge_page_check_structured_output

  def execute_existing_repos_and_installed_packages_check(self, config):
      Logger.info("Installed packages and existing repos checks started.")

      installedPackages = []
      availablePackages = []
      packages_analyzer.allInstalledPackages(installedPackages)
      packages_analyzer.allAvailablePackages(availablePackages)

      repos = []
      packages_analyzer.getInstalledRepos(self.PACKAGES, installedPackages + availablePackages,
                                      self.IGNORE_PACKAGES_FROM_REPOS, repos)
      packagesInstalled = packages_analyzer.getInstalledPkgsByRepo(repos, self.IGNORE_PACKAGES, installedPackages)
      additionalPkgsInstalled = packages_analyzer.getInstalledPkgsByNames(
        self.ADDITIONAL_PACKAGES, installedPackages)
      allPackages = list(set(packagesInstalled + additionalPkgsInstalled))
      
      installedPackages = packages_analyzer.getPackageDetails(installedPackages, allPackages)
      repos = packages_analyzer.getReposToRemove(repos, self.IGNORE_REPOS)

      Logger.info("Installed packages and existing repos checks completed.")
      return installedPackages, repos


  def execute_java_home_available_check(self, config):
    Logger.info("Java home check started.")
    java_home = config['commandParams']['java_home']

    Logger.info("Java home to check: " + java_home)
    java_bin = "java"
    if OSCheck.is_windows_family():
      java_bin = "java.exe"
  
    if not os.path.isfile(os.path.join(java_home, "bin", java_bin)):
      Logger.warning("Java home doesn't exist!")
      java_home_check_structured_output = {"exit_code" : 1, "message": "Java home doesn't exist!"}
    else:
      Logger.info("Java home exists!")
      java_home_check_structured_output = {"exit_code" : 0, "message": "Java home exists!"}

    Logger.info("Java home check completed.")
    return java_home_check_structured_output


  def execute_db_connection_check(self, config, tmp_dir):
    Logger.info("DB connection check started.")
  
    # initialize needed data
  
    ambari_server_hostname = config['commandParams']['ambari_server_host']
    check_db_connection_jar_name = "DBConnectionVerification.jar"
    jdk_location = config['commandParams']['jdk_location']
    java_home = config['commandParams']['java_home']
    db_name = config['commandParams']['db_name']
    no_jdbc_error_message = None

    if db_name == DB_MYSQL:
      jdbc_driver_mysql_name = default("/hostLevelParams/custom_mysql_jdbc_name", None)
      if not jdbc_driver_mysql_name:
        no_jdbc_error_message = "The MySQL JDBC driver has not been set. Please ensure that you have executed 'ambari-server setup --jdbc-db=mysql --jdbc-driver=/path/to/jdbc_driver'."
      else:
        jdbc_url = jdk_location + jdbc_driver_mysql_name
        jdbc_driver_class = JDBC_DRIVER_CLASS_MYSQL
        jdbc_name = jdbc_driver_mysql_name
    elif db_name == DB_ORACLE:
      jdbc_driver_oracle_name = default("/hostLevelParams/custom_oracle_jdbc_name", None)
      if not jdbc_driver_oracle_name:
        no_jdbc_error_message = "The Oracle JDBC driver has not been set. Please ensure that you have executed 'ambari-server setup --jdbc-db=oracle --jdbc-driver=/path/to/jdbc_driver'."
      else:
        jdbc_url = jdk_location + jdbc_driver_oracle_name
        jdbc_driver_class = JDBC_DRIVER_CLASS_ORACLE
        jdbc_name = jdbc_driver_oracle_name
    elif db_name == DB_POSTGRESQL:
      jdbc_driver_postgres_name = default("/hostLevelParams/custom_postgres_jdbc_name", None)
      if not jdbc_driver_postgres_name:
        no_jdbc_error_message = "The Postgres JDBC driver has not been set. Please ensure that you have executed 'ambari-server setup --jdbc-db=postgres --jdbc-driver=/path/to/jdbc_driver'."
      else:
        jdbc_url = jdk_location + jdbc_driver_postgres_name
        jdbc_driver_class = JDBC_DRIVER_CLASS_POSTGRESQL
        jdbc_name = jdbc_driver_postgres_name
    elif db_name == DB_MSSQL:
      jdbc_driver_mssql_name = default("/hostLevelParams/custom_mssql_jdbc_name", None)
      if not jdbc_driver_mssql_name:
        no_jdbc_error_message = "The MSSQL JDBC driver has not been set. Please ensure that you have executed 'ambari-server setup --jdbc-db=mssql --jdbc-driver=/path/to/jdbc_driver'."
      else:
        jdbc_url = jdk_location + jdbc_driver_mssql_name
        jdbc_driver_class = JDBC_DRIVER_CLASS_MSSQL
        jdbc_name = jdbc_driver_mssql_name
    elif db_name == DB_SQLA:
      jdbc_driver_sqla_name = default("/hostLevelParams/custom_sqlanywhere_jdbc_name", None)
      if not jdbc_driver_sqla_name:
        no_jdbc_error_message = "The SQLAnywhere JDBC driver has not been set. Please ensure that you have executed 'ambari-server setup --jdbc-db=sqlanywhere --jdbc-driver=/path/to/jdbc_driver'."
      else:
        jdbc_url = jdk_location + jdbc_driver_sqla_name
        jdbc_driver_class = JDBC_DRIVER_CLASS_SQLA
        jdbc_name = jdbc_driver_sqla_name

    if no_jdbc_error_message:
      Logger.warning(no_jdbc_error_message)
      db_connection_check_structured_output = {"exit_code" : 1, "message": no_jdbc_error_message}
      return db_connection_check_structured_output

    db_connection_url = config['commandParams']['db_connection_url']
    user_name = config['commandParams']['user_name']
    user_passwd = config['commandParams']['user_passwd']
    agent_cache_dir = os.path.abspath(config["hostLevelParams"]["agentCacheDir"])
    check_db_connection_url = jdk_location + check_db_connection_jar_name
    jdbc_path = os.path.join(agent_cache_dir, jdbc_name)
    class_path_delimiter = ":"
    if db_name == DB_SQLA:
      jdbc_jar_path = agent_cache_dir + JDBC_DRIVER_SQLA_JAR_PATH_IN_ARCHIVE
      java_library_path = agent_cache_dir + JARS_PATH_IN_ARCHIVE_SQLA + class_path_delimiter + agent_cache_dir + \
                          LIBS_PATH_IN_ARCHIVE_SQLA
    else:
      jdbc_jar_path = jdbc_path
      java_library_path = agent_cache_dir

    check_db_connection_path = os.path.join(agent_cache_dir, check_db_connection_jar_name)

    java_bin = "java"
    if OSCheck.is_windows_family():
      java_bin = "java.exe"
      class_path_delimiter = ";"

    java_exec = os.path.join(java_home, "bin",java_bin)

    if ('jdk_name' not in config['commandParams'] or config['commandParams']['jdk_name'] == None \
        or config['commandParams']['jdk_name'] == '') and not os.path.isfile(java_exec):
      message = "Custom java is not available on host. Please install it. Java home should be the same as on server. " \
                "\n"
      Logger.warning(message)
      db_connection_check_structured_output = {"exit_code" : 1, "message": message}
      return db_connection_check_structured_output

    environment = { "no_proxy": format("{ambari_server_hostname}") }
    # download and install java if it doesn't exists
    if not os.path.isfile(java_exec):
      jdk_name = config['commandParams']['jdk_name']
      jdk_url = "{0}/{1}".format(jdk_location, jdk_name)
      jdk_download_target = os.path.join(agent_cache_dir, jdk_name)
      java_dir = os.path.dirname(java_home)
      try:
        download_file(jdk_url, jdk_download_target)
      except Exception, e:
        message = "Error downloading JDK from Ambari Server resources. Check network access to " \
                  "Ambari Server.\n" + str(e)
        Logger.exception(message)
        db_connection_check_structured_output = {"exit_code" : 1, "message": message}
        return db_connection_check_structured_output

      if jdk_name.endswith(".exe"):
        install_cmd = "{0} /s INSTALLDIR={1} STATIC=1 WEB_JAVA=0 /L \\var\\log\\ambari-agent".format(
        os_utils.quote_path(jdk_download_target), os_utils.quote_path(java_home),
        )
        install_path = [java_dir]
        try:
          Execute(install_cmd, path = install_path)
        except Exception, e:
          message = "Error installing java.\n" + str(e)
          Logger.exception(message)
          db_connection_check_structured_output = {"exit_code" : 1, "message": message}
          return db_connection_check_structured_output
      else:
        tmp_java_dir = tempfile.mkdtemp(prefix="jdk_tmp_", dir=tmp_dir)
        sudo = AMBARI_SUDO_BINARY
        if jdk_name.endswith(".bin"):
          chmod_cmd = ("chmod", "+x", jdk_download_target)
          install_cmd = format("cd {tmp_java_dir} && echo A | {jdk_download_target} -noregister && {sudo} cp -rp {tmp_java_dir}/* {java_dir}")
        elif jdk_name.endswith(".gz"):
          chmod_cmd = ("chmod","a+x", java_dir)
          install_cmd = format("cd {tmp_java_dir} && tar -xf {jdk_download_target} && {sudo} cp -rp {tmp_java_dir}/* {java_dir}")
        try:
          Directory(java_dir)
          Execute(chmod_cmd, not_if = format("test -e {java_exec}"), sudo = True)
          Execute(install_cmd, not_if = format("test -e {java_exec}"))
          File(format("{java_home}/bin/java"), mode=0755, cd_access="a")
          Directory(java_home, owner=getpass.getuser(), recursive_ownership=True)
          Execute(('chmod', '-R', '755', java_home), sudo = True)
        except Exception, e:
          message = "Error installing java.\n" + str(e)
          Logger.exception(message)
          db_connection_check_structured_output = {"exit_code" : 1, "message": message}
          return db_connection_check_structured_output
        finally:
          Directory(tmp_java_dir, action="delete")

    # download DBConnectionVerification.jar from ambari-server resources
    try:
      download_file(check_db_connection_url, check_db_connection_path)

    except Exception, e:
      message = "Error downloading DBConnectionVerification.jar from Ambari Server resources. Check network access to " \
                "Ambari Server.\n" + str(e)
      Logger.exception(message)
      db_connection_check_structured_output = {"exit_code" : 1, "message": message}
      return db_connection_check_structured_output
  
    # download jdbc driver from ambari-server resources
    try:
      download_file(jdbc_url, jdbc_path)
      if db_name == DB_MSSQL and OSCheck.is_windows_family():
        jdbc_auth_path = os.path.join(agent_cache_dir, JDBC_AUTH_SYMLINK_MSSQL)
        jdbc_auth_url = jdk_location + JDBC_AUTH_SYMLINK_MSSQL
        download_file(jdbc_auth_url, jdbc_auth_path)
      elif db_name == DB_SQLA:
        # unpack tar.gz jdbc which was donaloaded
        untar_sqla_type2_driver = ('tar', '-xvf', jdbc_path, '-C', agent_cache_dir)
        Execute(untar_sqla_type2_driver, sudo = True)
    except Exception, e:
      message = format("Error: Ambari Server cannot download the database JDBC driver and is unable to test the " \
                "database connection. You must run ambari-server setup --jdbc-db={db_name} " \
                "--jdbc-driver=/path/to/your/{db_name}/driver.jar on the Ambari Server host to make the JDBC " \
                "driver available for download and to enable testing the database connection.\n") + str(e)
      Logger.exception(message)
      db_connection_check_structured_output = {"exit_code" : 1, "message": message}
      return db_connection_check_structured_output

    # For Oracle connection as SYS should be as SYSDBA
    if db_name == DB_ORACLE and user_name.upper() == "SYS":
      user_name = "SYS AS SYSDBA"

    # try to connect to db
    db_connection_check_command = format("{java_exec} -cp {check_db_connection_path}{class_path_delimiter}" \
           "{jdbc_jar_path} -Djava.library.path={java_library_path} org.apache.ambari.server.DBConnectionVerification \"{db_connection_url}\" " \
           "\"{user_name}\" {user_passwd!p} {jdbc_driver_class}")

    if db_name == DB_SQLA:
      db_connection_check_command = "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{0}{1} {2}".format(agent_cache_dir,
                                                                LIBS_PATH_IN_ARCHIVE_SQLA, db_connection_check_command)

    code, out = shell.call(db_connection_check_command)

    if code == 0:
      db_connection_check_structured_output = {"exit_code" : 0, "message": "DB connection check completed successfully!" }
    else:
      db_connection_check_structured_output = {"exit_code" : 1, "message":  out }

    Logger.info("DB connection check completed.")
    return db_connection_check_structured_output

  # check whether each host in the command can be resolved to an IP address
  def execute_host_resolution_check(self, config):
    Logger.info("IP address forward resolution check started.")
    
    FORWARD_LOOKUP_REASON = "FORWARD_LOOKUP"
    
    failedCount = 0
    failures = []
   
    if config['commandParams']['hosts'] is not None :
      hosts = config['commandParams']['hosts'].split(",")
      successCount = len(hosts)
    else :
      successCount = 0
      hosts = ""
          
    socket.setdefaulttimeout(3)          
    for host in hosts:
      try:
        host = host.strip()        
        socket.gethostbyname(host)
      except socket.error,exception:
        successCount -= 1
        failedCount += 1
        
        failure = { "host": host, "type": FORWARD_LOOKUP_REASON, 
          "cause": exception.args }
        
        failures.append(failure)
  
    if failedCount > 0 :
      message = "There were " + str(failedCount) + " host(s) that could not resolve to an IP address."
    else :
      message = "All hosts resolved to an IP address."

    Logger.info(message)
        
    host_resolution_check_structured_output = {
      "exit_code" : 0,
      "message" : message,                                          
      "failed_count" : failedCount, 
      "success_count" : successCount,
      "failures" : failures
      }

    Logger.info("IP address forward resolution check completed.")
    return host_resolution_check_structured_output

  # computes and returns the host information of the agent
  def execute_last_agent_env_check(self):
    Logger.info("Last Agent Env check started.")
    hostInfo = HostInfo()
    last_agent_env_check_structured_output = { }
    hostInfo.register(last_agent_env_check_structured_output, False, False)
    Logger.info("Last Agent Env check completed successfully.")

    return last_agent_env_check_structured_output

if __name__ == "__main__":
  CheckHost().execute()
