daktari 0.0.254__py3-none-any.whl → 0.0.255__py3-none-any.whl

daktari/checks/google.py

@@ -0,0 +1,113 @@
+import json
+import logging
+import os.path
+from json import JSONDecodeError
+from typing import Optional
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import can_run_command
+from daktari.file_utils import file_exists
+from daktari.os import OS
+from daktari.version_utils import get_simple_cli_version
+
+
+class GoogleCloudSdkInstalled(Check):
+    name = "google.cloudSdkInstalled"
+
+    suggestions = {
+        OS.OS_X: """<cmd>brew install --cask google-cloud-sdk</cmd>
+
+Then, add the gcloud components to your PATH.
+
+For bash users, add this to ~/.bashrc:
+source "$(brew --prefix)/Caskroom/google-cloud-sdk/latest/google-cloud-sdk/path.bash.inc"
+
+For zsh users, add this to ~/.zhsrc:
+source "$(brew --prefix)/Caskroom/google-cloud-sdk/latest/google-cloud-sdk/path.zsh.inc\" """,
+        OS.UBUNTU: "<cmd>sudo snap install google-cloud-sdk --classic</cmd>",
+        OS.GENERIC: "Install gcloud: https://cloud.google.com/sdk/docs/quickstart",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_command("gcloud --version"), "Google Cloud SDK is <not/> installed and on $PATH")
+
+
+class CloudSqlProxyInstalled(Check):
+    name = "google.cloudSqlProxyInstalled"
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    suggestions = {
+        OS.GENERIC: "Install Cloud SQL Proxy: <cmd>gcloud components install cloud_sql_proxy</cmd>",
+    }
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("cloud_sql_proxy")
+        return self.validate_semver_expression(
+            "cloud_sql_proxy", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class GkeGcloudAuthPluginInstalled(Check):
+    name = "google.gkeGcloudAuthPluginInstalled"
+    depends_on = [GoogleCloudSdkInstalled]
+
+    suggestions = {
+        OS.UBUNTU: "<cmd>sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin</cmd>",
+        OS.GENERIC: "<cmd>gcloud components install gke-gcloud-auth-plugin</cmd>",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_command("gke-gcloud-auth-plugin --version "), "GKE auth plugin is <not/> installed")
+
+
+class DockerGoogleCloudAuthConfigured(Check):
+    name = "google.dockerGCloudAuthConfigured"
+    depends_on = [GoogleCloudSdkInstalled]
+
+    def __init__(self, cloud_project, region, registry):
+        self.registry = registry
+        self.suggestions = {
+            OS.GENERIC: f"""
+                Setup gcloud authentication and docker credential helper for gcloud.
+                The following commands will open your browser and ask you to login and approve.
+                Run:
+                <cmd>rm -r ~/.config/gcloud</cmd>
+                <cmd>gcloud auth login</cmd>
+                <cmd>gcloud config set project {cloud_project}</cmd>
+                <cmd>gcloud config set --quiet compute/zone {region}</cmd>
+                <cmd>gcloud auth application-default login</cmd>
+                <cmd>gcloud auth configure-docker {registry}</cmd>
+                """
+        }
+
+    def check(self) -> CheckResult:
+        # Logged in with gcloud
+        google_config_path = os.path.expanduser("~/.config/gcloud/application_default_credentials.json")
+        if not file_exists(google_config_path):
+            return self.failed(f"{google_config_path} does not exist")
+
+        if not can_run_command("gcloud auth application-default print-access-token"):
+            return self.failed("Application Default Credentials are not correctly set up")
+
+        # Docker configured correctly
+        docker_config_path = os.path.expanduser("~/.docker/config.json")
+        if not file_exists(docker_config_path):
+            return self.failed(f"{docker_config_path} does not exist")
+
+        try:
+            with open(docker_config_path, "rb") as docker_config_file:
+                docker_config = json.load(docker_config_file)
+        except IOError:
+            logging.error(f"Exception reading {docker_config_path}", exc_info=True)
+            return self.failed(f"Failed to read {docker_config_path}")
+        except JSONDecodeError:
+            logging.error(f"Exception parsing {docker_config_path}", exc_info=True)
+            return self.failed(f"Failed to parse {docker_config_path}")
+
+        if docker_config.get("credHelpers", {}).get(self.registry) != "gcloud":
+            return self.failed("docker gcloud auth for {self.registry} not configured")
+
+        return self.passed("docker gcloud auth configured")

daktari/checks/intellij_idea.py

@@ -0,0 +1,248 @@
+import json
+import logging
+import os
+from json.decoder import JSONDecodeError
+from pathlib import Path
+from typing import Optional
+from xml.etree.ElementTree import Element
+
+import dpath.util
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.checks.files import FilesExist
+from daktari.checks.xml import XmlFileXPathCheck
+from daktari.command_utils import get_stdout
+from daktari.os import OS, detect_os
+from daktari.version_utils import try_parse_semver, sanitise_version_string
+
+BUNDLE_ID_INTELLIJ_IDEA = "com.jetbrains.intellij"
+BUNDLE_ID_INTELLIJ_IDEA_CE = "com.jetbrains.intellij.ce"
+
+SNAP_NAME_INTELLIJ_IDEA = "intellij-idea-ultimate"
+SNAP_NAME_INTELLIJ_IDEA_CE = "intellij-idea-community"
+
+
+def locate_intellij_idea_mac():
+    from AppKit import NSWorkspace
+
+    for bundle_id in (BUNDLE_ID_INTELLIJ_IDEA, BUNDLE_ID_INTELLIJ_IDEA_CE):
+        url = NSWorkspace.sharedWorkspace().URLForApplicationWithBundleIdentifier_(bundle_id)
+        if url is not None:
+            logging.debug(f"IntelliJ IDEA location (via NSWorkspace): {url}")
+            return url
+
+    logging.debug("Could not find IntelliJ IDEA (via NSWorkspace)")
+    return None
+
+
+def get_intellij_idea_version_mac() -> Optional[VersionInfo]:
+    intellij_url = locate_intellij_idea_mac()
+    if intellij_url is None:
+        return None
+    else:
+        from Foundation import NSBundle
+
+        version_str = NSBundle.bundleWithURL_(intellij_url).objectForInfoDictionaryKey_("CFBundleShortVersionString")
+
+        version_str = sanitise_version_string(version_str)
+        version = try_parse_semver(version_str)
+
+        logging.debug(f"IntelliJ IDEA version (via NSBundle): {version} ({version_str})")
+        return version
+
+
+def get_intellij_idea_version_snap() -> Optional[VersionInfo]:
+    if not Path("/run/snapd.socket").is_socket():
+        logging.debug("/run/snapd.socket does not exist, not querying snapd")
+        return None
+
+    from requests_unixsocket import Session
+
+    session = Session()
+    snaps_req = session.get(
+        f"http+unix://%2Frun%2Fsnapd.socket/v2/snaps?snaps={SNAP_NAME_INTELLIJ_IDEA},{SNAP_NAME_INTELLIJ_IDEA_CE}"
+    )
+    snaps_info = snaps_req.json()
+    logging.debug(f"response from snapd: {snaps_info}")
+    version_str = dpath.util.get(snaps_info, "/result/0/version", default=None)
+    logging.debug(f"raw snapd version: {version_str}")
+    if not isinstance(version_str, str):
+        return None
+    version_str = sanitise_version_string(version_str)
+
+    version = try_parse_semver(version_str)
+    logging.debug(f"IntelliJ IDEA version (via snapd): {version}")
+    return version
+
+
+def get_intellij_idea_version_tarball() -> Optional[VersionInfo]:
+    idea_bin_path = get_stdout(["sh", "-c", "which idea.sh"])
+    if idea_bin_path is None:
+        return None
+
+    product_info_path = os.path.join(os.path.dirname(idea_bin_path), "..", "product-info.json")
+    return get_intellij_version_from_product_info(product_info_path)
+
+
+def get_intellij_idea_toolbox_version() -> Optional[VersionInfo]:
+    idea_bin_path = get_stdout(["sh", "-c", "which idea"])
+    if idea_bin_path is None:
+        return None
+
+    apps_dir = os.path.join(os.path.dirname(idea_bin_path), "..", "apps")
+    toolbox_apps = os.listdir(apps_dir)
+    logging.debug(f"Toolbox apps found: {toolbox_apps}", exc_info=True)
+    intellij_installs = [app for app in toolbox_apps if "intellij-idea" in app]
+    if len(intellij_installs) == 0:
+        logging.debug("No IntelliJ IDEA installs found")
+        return None
+
+    product_info_path = os.path.join(apps_dir, intellij_installs[0], "product-info.json")
+    return get_intellij_version_from_product_info(product_info_path)
+
+
+def get_intellij_version_from_product_info(product_info_path: str) -> Optional[VersionInfo]:
+    try:
+        with open(product_info_path, "rb") as product_info_file:
+            product_info = json.load(product_info_file)
+    except IOError:
+        logging.debug("Failed to read IntelliJ IDEA product-info.json", exc_info=True)
+        return None
+    except JSONDecodeError:
+        logging.debug("Failed to parse IntelliJ IDEA product-info.json", exc_info=True)
+        return None
+
+    version_str = product_info.get("version", None)
+    version = try_parse_semver(version_str)
+    logging.debug(f"IntelliJ IDEA version (via product-info.json): {version}")
+    return version
+
+
+def get_intellij_idea_version() -> Optional[VersionInfo]:
+    os = detect_os()
+    if os == OS.OS_X:
+        return get_intellij_idea_version_mac()
+    elif os == OS.UBUNTU:
+        return (
+            get_intellij_idea_version_snap()
+            or get_intellij_idea_version_tarball()
+            or get_intellij_idea_toolbox_version()
+        )
+    else:
+        return get_intellij_idea_version_tarball() or get_intellij_idea_toolbox_version()
+
+
+class IntelliJIdeaInstalled(Check):
+    name = "intellij.installed"
+
+    suggestions = {OS.GENERIC: "Install IntelliJ Ultimate: https://www.jetbrains.com/idea/download/"}
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    def check(self) -> CheckResult:
+        intellij_version = get_intellij_idea_version()
+        return self.validate_semver_expression(
+            "IntelliJ IDEA", intellij_version, self.required_version, self.recommended_version
+        )
+
+
+class IntelliJProjectImported(FilesExist):
+    name = "intellij.projectImported"
+    file_paths = [".idea/workspace.xml"]
+    pass_fail_message = "Project <not/> imported into IntelliJ"
+    depends_on = [IntelliJIdeaInstalled]
+    suggestions = {
+        OS.GENERIC: """
+            From the IntelliJ start screen, click 'Open or Import' and choose the repository root directory
+            """
+    }
+
+
+class IntelliJNodePackageManagerConfigured(XmlFileXPathCheck):
+    name = "intellij.nodePackageManagerConfigured"
+    file_path = ".idea/workspace.xml"
+    xpath_query = "./component[@name='PropertiesComponent']"
+    depends_on = [IntelliJProjectImported]
+
+    def __init__(self, package_manager_path: str):
+        self.package_manager_path = package_manager_path
+        self.pass_fail_message = f"IntelliJ package manager has <not/> been set to {package_manager_path}"
+
+        self.suggestions = {
+            OS.GENERIC: f"""
+                Follow the steps to configure {self.package_manager_path} as your package manager:
+                https://www.jetbrains.com/help/idea/installing-and-removing-external-software-using-node-package-manager.html#ws_npm_yarn_configure_package_manager
+                """
+        }
+
+    def validate_query_result(self, result):
+        key_json = None if result is None else json.loads(result.text)
+        logging.debug(f"Raw properties json: {key_json}")
+        current_package_manager = str(key_json["keyToString"]["nodejs_package_manager_path"])
+        logging.debug(f"IntelliJ node package manager set to: {current_package_manager}")
+        return current_package_manager.__contains__(self.package_manager_path)
+
+
+class IntelliJTypescriptCompilerPathConfigured(XmlFileXPathCheck):
+    name = "intellij.typescriptCompilerPathConfigured"
+    file_path = ".idea/compiler.xml"
+    xpath_query = "./component[@name='TypeScriptCompiler']/option[@name='typeScriptServiceDirectory']"
+    depends_on = [IntelliJProjectImported]
+
+    def __init__(self, typescript_compiler_path: str):
+        self.typescript_compiler_path = typescript_compiler_path
+        resolved_path = typescript_compiler_path.replace("$PROJECT_DIR$", os.getcwd())
+        self.pass_fail_message = f"IntelliJ typescript compiler path has <not/> been set to {resolved_path}"
+
+        self.suggestions = {
+            OS.GENERIC: f"""
+                Follow the steps to set {resolved_path} as your typescript compiler path:
+                https://www.jetbrains.com/help/idea/typescript-support.html#ws_ts_use_ts_service_checkbox
+                """
+        }
+
+    def validate_query_result(self, result):
+        if result is None:
+            self.pass_fail_message = "IntelliJ typescript compiler path is <not/> set"
+            return False
+        current_typescript_compiler_path = result.get("value")
+        logging.debug(f"IntelliJ typescript compiler set to: {current_typescript_compiler_path}")
+        return current_typescript_compiler_path == self.typescript_compiler_path
+
+
+class IntelliJProjectSdkJavaVersion(XmlFileXPathCheck):
+    name = "intellij.jdkVersionConfigured"
+    file_path = ".idea/misc.xml"
+    xpath_query = "./component[@name='ProjectRootManager']"
+    depends_on = [IntelliJProjectImported]
+
+    def __init__(self, jdk_version: int):
+        self.jdk_version = jdk_version
+
+        self.suggestions = {
+            OS.GENERIC: f"""
+                Follow the steps to configure JDK {jdk_version}:
+                https://www.jetbrains.com/help/idea/sdk.html#change-project-sdk
+                """
+        }
+
+    def validate_query_result(self, result: Optional[Element]):
+        if result is None:
+            self.pass_fail_message = "IntelliJ Project SDK is not set"
+            return False
+
+        try:
+            jdk_type = result.attrib["project-jdk-type"]
+            if jdk_type != "JavaSDK":
+                self.pass_fail_message = f"IntelliJ Project SDK is not a Java JDK: {jdk_type}"
+                return False
+        except KeyError:
+            self.pass_fail_message = "IntelliJ Project SDK is not a Java JDK"
+            return False
+
+        language_level = result.attrib["languageLevel"]
+        self.pass_fail_message = f"IntelliJ Project SDK is <not/> set to Java {self.jdk_version}: {language_level}"
+        return language_level == f"JDK_{self.jdk_version}"

daktari/checks/java.py

@@ -0,0 +1,104 @@
+import logging
+import re
+from typing import Optional
+
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stderr, run_command
+from daktari.os import OS
+
+java_version_pattern = re.compile('^.*version "(.*?)".*$', re.MULTILINE)
+javac_version_pattern = re.compile("^javac (.*)$", re.MULTILINE)
+
+one_dot_pattern = re.compile("1\\.([0-9]+)")
+other_pattern = re.compile("([0-9]+)")
+
+
+def get_java_version() -> Optional[VersionInfo]:
+    version_output = get_stderr("java -version")
+    return parse_java_version_output(version_output)
+
+
+def get_jdk_version() -> Optional[VersionInfo]:
+    try:
+        version_output = run_command("javac -version")
+    except Exception:
+        return None
+
+    return parse_javac_version_output(version_output.stdout + version_output.stderr)
+
+
+def parse_java_version_output(version_output: Optional[str]) -> Optional[VersionInfo]:
+    if version_output:
+        match = java_version_pattern.search(version_output)
+        if match:
+            version_string = match.group(1)
+            logging.debug(f"Java version string: {version_string}")
+            return parse_java_version_string(version_string)
+    return None
+
+
+def parse_javac_version_output(version_output: Optional[str]) -> Optional[VersionInfo]:
+    if version_output:
+        match = javac_version_pattern.search(version_output)
+        if match:
+            version_string = match.group(1)
+            logging.debug(f"JDK version string: {version_string}")
+            return parse_java_version_string(version_string)
+    return None
+
+
+def parse_java_version_string(version_string: str) -> Optional[VersionInfo]:
+    try:
+        return VersionInfo.parse(version_string)
+    except ValueError:
+        return parse_alternative_java_version_numbers(version_string)
+
+
+def parse_alternative_java_version_numbers(version_string: str) -> Optional[VersionInfo]:
+    one_dot_match = one_dot_pattern.search(version_string)
+    if one_dot_match:
+        return VersionInfo(int(one_dot_match.group(1)))
+    other_pattern_match = other_pattern.search(version_string)
+    if other_pattern_match:
+        return VersionInfo(int(other_pattern_match.group(1)))
+    return None
+
+
+class JavaVersion(Check):
+    name = "java.version"
+
+    def __init__(
+        self,
+        required_version: Optional[str] = None,
+        recommended_version: Optional[str] = None,
+        java_instructions: Optional[str] = None,
+    ):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+        java_instructions = f"\n\n{java_instructions}" if java_instructions else ""
+        self.suggestions = {OS.GENERIC: f"""Install Java{java_instructions}"""}
+
+    def check(self) -> CheckResult:
+        java_version = get_java_version()
+        logging.info(f"Java version: {java_version}")
+        return self.validate_semver_expression("Java", java_version, self.required_version, self.recommended_version)
+
+
+class JdkVersion(Check):
+    name = "jdk.version"
+
+    def __init__(self, required_version: str, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    suggestions = {
+        OS.GENERIC: "Install Java JDK",
+    }
+
+    def check(self) -> CheckResult:
+        jdk_version = get_jdk_version()
+        logging.info(f"JDK version: {jdk_version}")
+        return self.validate_semver_expression("JDK", jdk_version, self.required_version, self.recommended_version)

daktari/checks/kubernetes.py

@@ -0,0 +1,154 @@
+import json
+import logging
+import re
+from typing import Optional, List
+
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout, can_run_command
+from daktari.os import OS
+from daktari.version_utils import try_parse_semver
+from daktari.checks.google import GkeGcloudAuthPluginInstalled
+
+
+class KubectlInstalled(Check):
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+        self.name = "kubectl.installed"
+        self.suggestions = {
+            OS.OS_X: "<cmd>brew install kubectl</cmd>",
+            OS.UBUNTU: "<cmd>sudo snap install kubectl --classic</cmd>",
+            OS.GENERIC: "Install kubectl: https://kubernetes.io/docs/tasks/tools/#kubectl",
+        }
+
+    def check(self) -> CheckResult:
+        installed_version = get_kubectl_version()
+        return self.validate_semver_expression(
+            "Kubectl", installed_version, self.required_version, self.recommended_version
+        )
+
+
+version_pattern = re.compile("Client Version: v(.*)")
+
+
+def get_kubectl_version() -> Optional[VersionInfo]:
+    raw_version = get_stdout("kubectl version --client=true --short")
+    # Handle deprecation of --short
+    if raw_version is None:
+        raw_version = get_stdout("kubectl version --client=true")
+
+    if raw_version:
+        match = version_pattern.search(raw_version)
+        if match:
+            version = try_parse_semver(match.group(1))
+            logging.debug(f"Kubectl version: {version}")
+            return version
+    return None
+
+
+class KubectlContextExists(Check):
+    depends_on = [GkeGcloudAuthPluginInstalled]
+
+    def __init__(self, context_name: str, provision_command: str = ""):
+        self.context_name = context_name
+        self.name = f"kubectl.contextExists.{context_name}"
+        self.suggestions = {OS.GENERIC: provision_command}
+
+    def check(self) -> CheckResult:
+        output = get_stdout("kubectl config get-contexts")
+        passed = bool(output and self.context_name in output)
+        if not passed:
+            return self.failed(f"{self.context_name} is <not/> configured for the current user")
+
+        can_connect = can_run_command(f"kubectl get ns --context {self.context_name}")
+        return self.verify(can_connect, f"Could <not/> connect to context {self.context_name}")
+
+
+class KubectlNoExtraneousContexts(Check):
+    def __init__(self, expected_contexts: List[str]):
+        self.expected_contexts = expected_contexts
+        self.name = "kubectl.noExtraneousContexts"
+
+    def check(self) -> CheckResult:
+        output = get_stdout("kubectl config get-contexts -o name")
+        if not output:
+            return self.failed("Failed to list kubectl contexts")
+
+        contexts = output.splitlines()
+        extraneous_contexts = list(filter(lambda context: context not in self.expected_contexts, contexts))
+        if extraneous_contexts:
+            suggestion = "\n".join(
+                f"<cmd>kubectl config delete-context {context}</cmd>" for context in extraneous_contexts
+            )
+            self.suggestions = {
+                OS.GENERIC: suggestion,
+            }
+            return self.passed_with_warning(f"{len(extraneous_contexts)} extraneous kubectl context(s) found")
+
+        return self.passed("No extraneous kubectl contexts found")
+
+
+class HelmInstalled(Check):
+    name = "helm.installed"
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+        self.suggestions = {
+            OS.OS_X: "<cmd>brew install helm</cmd>",
+            OS.UBUNTU: "<cmd>sudo snap install helm --classic</cmd>",
+            OS.GENERIC: "Install Helm: https://helm.sh/docs/intro/install/",
+        }
+
+    def check(self) -> CheckResult:
+        installed_version = get_helm_version()
+        return self.validate_semver_expression(
+            "Helm", installed_version, self.required_version, self.recommended_version
+        )
+
+
+helm_version_pattern = re.compile("v([0-9\\.]+)")
+
+
+def get_helm_version() -> Optional[VersionInfo]:
+    raw_version = get_stdout("helm version --short")
+    if raw_version:
+        match = helm_version_pattern.search(raw_version)
+        if match:
+            version = try_parse_semver(match.group(1))
+            logging.debug(f"Helm Version: {version}")
+            return version
+    return None
+
+
+class HelmRepoExists(Check):
+    depends_on = [HelmInstalled]
+
+    def __init__(self, repo_name: str, repo_url: str):
+        self.repo_name = repo_name
+        self.repo_url = repo_url.strip("/")
+        self.name = f"helm.repoExists.{repo_name}"
+        self.suggestions = {
+            OS.GENERIC: f"<cmd>helm repo add {repo_name} {repo_url} --force-update</cmd>",
+        }
+
+    def check(self) -> CheckResult:
+        output = get_stdout("helm repo list -o json")
+        if not output:
+            return self.failed("No helm repos appear to be configured for the current user.")
+        repo_json = json.loads(output)
+        repo = next(filter(lambda repo_details: repo_details.get("name") == self.repo_name, repo_json), None)
+        if repo is None:
+            return self.failed(f"{self.repo_name} is not configured for the current user")
+
+        installed_url = repo["url"].strip("/")
+        logging.debug(f"{self.repo_name} helm repo is installed with URL {installed_url}.")
+
+        if installed_url != self.repo_url:
+            return self.failed(
+                f"{self.repo_name} is configured to use the wrong URL. Expected {self.repo_url}, got {installed_url}"
+            )
+
+        return self.passed(f"{self.repo_name} is configured for the current user")