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

daktari/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.254"
+__version__ = "0.0.255"

daktari/checks/android.py

@@ -0,0 +1,26 @@
+from daktari.check import Check, CheckResult
+from daktari.os import OS, get_env_var_value
+
+
+class AndroidNdkHomeSet(Check):
+    name = "android.ndkHomeSet"
+
+    def __init__(self, expected_version):
+        self.variable_name = "ANDROID_NDK_HOME"
+        self.expected_version = expected_version
+        self.suggestions = {
+            OS.GENERIC: f"""
+            Export {self.variable_name} in your shell config.
+            The expected value is ANDROID_SDK_HOME/ndk/{self.expected_version}.
+            If you manage your android sdk using Android Studio, you can find your ANDROID_SDK_HOME by going to
+            Tools > SDK Manager and copying the Android SDK location.
+            You may need to check under SDK Tools that you have the NDK installed.
+            """
+        }
+
+    def check(self) -> CheckResult:
+        expected_substring = f"ndk/{self.expected_version}"
+        return self.verify(
+            expected_substring in get_env_var_value(self.variable_name),
+            f"{self.variable_name} is <not/> set with expected version {self.expected_version}",
+        )

daktari/checks/aws.py

@@ -0,0 +1,34 @@
+from daktari.check import Check, CheckResult
+from daktari.command_utils import can_run_command, get_stdout
+from daktari.os import OS
+
+
+class AWSCLIInstalled(Check):
+    name = "aws.cliInstalled"
+
+    suggestions = {
+        OS.OS_X: """<cmd>curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg" && \
+    sudo installer -pkg AWSCLIV2.pkg -target /</cmd>""",
+        OS.UBUNTU: """"<cmd>curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && \
+    unzip awscliv2.zip && \
+    sudo ./aws/install</cmd>""",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_command("aws --version"), "AWS CLI is <not/> installed and on $PATH")
+
+
+class AWSProfileExists(Check):
+    depends_on = [AWSCLIInstalled]
+
+    def __init__(self, profile_name: str, suggestions: dict[str, str]):
+        self.profile_name = profile_name
+        self.name = f"aws.profileExists.{profile_name}"
+        self.suggestions = suggestions
+
+    def check(self) -> CheckResult:
+        output = get_stdout("aws configure list-profiles")
+        passed = bool(output and self.profile_name in output)
+        if not passed:
+            return self.failed(f"{self.profile_name} is not configured for the current user")
+        return self.passed(f"{self.profile_name} is configured for the current user")

daktari/checks/certs.py

@@ -0,0 +1,34 @@
+import logging
+import os
+from datetime import datetime
+from OpenSSL import crypto
+
+from daktari.check import Check, CheckResult
+from daktari.os import OS
+
+
+class CertificateIsNotExpired(Check):
+    name = "certificate.isNotExpired"
+
+    def __init__(self, certificate_path: str):
+        self.certificate_path = certificate_path
+        self.suggestions = {
+            OS.GENERIC: f"Regenerate the certificate at {certificate_path}",
+        }
+
+    def check(self) -> CheckResult:
+        with open(self.certificate_path, "rb") as f:
+            cert = crypto.load_certificate(crypto.FILETYPE_PEM, f.read())
+            logging.debug(f"Raw expiry: {cert.get_notAfter()!r}")
+
+            expiry_bytes = cert.get_notAfter()
+            if expiry_bytes is None:
+                return self.passed_with_warning(
+                    f"Unable to determine expiry date of {os.path.basename(self.certificate_path)}"
+                )
+
+            expiry = datetime.strptime(expiry_bytes.decode(), "%Y%m%d%H%M%SZ")
+            if expiry > datetime.now():
+                return self.passed(f"{os.path.basename(self.certificate_path)} is not expired")
+            else:
+                return self.failed(f"{os.path.basename(self.certificate_path)} expired on {expiry}")

daktari/checks/conan.py

@@ -0,0 +1,96 @@
+import json
+import logging
+from typing import Optional
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout
+from daktari.os import OS
+
+
+class ConanInstalled(Check):
+    name = "conan.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.GENERIC: "Install conan: <cmd>pip install conan</cmd>"}
+
+    def check(self) -> CheckResult:
+        return self.verify_install("conan")
+
+
+class ConanProfileDetected(Check):
+    name = "conan.profileDetected"
+
+    def __init__(self, expected_string: str):
+        self.suggestions = {OS.GENERIC: "<cmd>conan profile detect</cmd>"}
+        self.expected_string = expected_string
+        self.depends_on = [ConanInstalled]
+
+    def check(self) -> CheckResult:
+        output = get_stdout("conan profile list")
+        expected_profile_detected = output is not None and self.expected_string in output
+        return self.verify(expected_profile_detected, f"conan profile {self.expected_string} <not/> detected")
+
+
+class ConanRemoteDetected(Check):
+    name = "conan.remoteDetected"
+
+    def __init__(self, remote_name: str, remote_url: str):
+        self.suggestions = {OS.GENERIC: f"<cmd>conan remote add {remote_name} {remote_url}</cmd>"}
+        self.remote_name = remote_name
+        self.remote_url = remote_url
+        self.depends_on = [ConanInstalled]
+
+    def check(self) -> CheckResult:
+        output = get_stdout("conan remote list -f json")
+        if output is None:
+            return self.failed("No conan remotes configured for the current user.")
+        remote_json = json.loads(output)
+        remote = next(filter(lambda remote_details: remote_details.get("name") == self.remote_name, remote_json), None)
+        if remote is None:
+            return self.failed(f"{self.remote_name} conan remote is not configured for the current user.")
+
+        configured_url = remote["url"].strip("/")
+        logging.debug(f"{self.remote_name} conan remote is configured with URL {configured_url}.")
+
+        if configured_url != self.remote_url:
+            self.suggestions = {
+                OS.GENERIC: f"<cmd>conan remote update --url {self.remote_url} {self.remote_name}</cmd>"
+            }
+            return self.failed(
+                f"{self.remote_name} conan remote is configured with URL {configured_url}, expected {self.remote_url}"
+            )
+
+        if not remote["enabled"]:
+            self.suggestions = {OS.GENERIC: f"<cmd>conan remote enable {self.remote_name}</cmd>"}
+            return self.failed(f"{self.remote_name} conan remote is not enabled.")
+
+        return self.passed(f"{self.remote_name} conan remote is configured for the current user.")
+
+
+class ConanRemoteAuthenticated(Check):
+    name = "conan.remoteAuthenticated"
+
+    def __init__(self, remote_name: str, authentication_command: Optional[str] = None):
+        self.suggestions = (
+            {OS.GENERIC: authentication_command}
+            if authentication_command
+            else {OS.GENERIC: f"<cmd>conan remote login {remote_name}</cmd>"}
+        )
+        self.remote_name = remote_name
+        self.depends_on = [ConanRemoteDetected]
+
+    def check(self) -> CheckResult:
+        output = get_stdout("conan remote list-users -f json")
+        if output is None:
+            return self.failed("No conan remotes configured for the current user.")
+        remote_json = json.loads(output)
+        remote = next(filter(lambda remote_details: remote_details.get("name") == self.remote_name, remote_json), None)
+        if remote is None:
+            return self.failed(f"{self.remote_name} conan remote is not configured for the current user.")
+
+        if not remote["authenticated"]:
+            return self.failed(f"{self.remote_name} conan remote is not authenticated.")
+
+        return self.passed(f"{self.remote_name} conan remote is authenticated for the current user.")

daktari/checks/direnv.py

@@ -0,0 +1,59 @@
+import re
+
+from daktari.command_utils import get_stdout
+
+from daktari.os import OS
+from daktari.check import Check, CheckResult
+from daktari.version_utils import get_simple_cli_version
+from daktari.file_utils import file_contains_text
+from typing import Optional
+from os import getcwd
+
+
+class DirenvInstalled(Check):
+    name = "direnv.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.GENERIC: "Install direnv: https://direnv.net/#getting-started",
+            OS.OS_X: "Install direnv using brew: <cmd>brew install direnv</cmd>",
+            OS.UBUNTU: "Install direnv using apt-get: <cmd>sudo apt-get install direnv</cmd>",
+        }
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("direnv")
+        return self.validate_semver_expression(
+            "direnv", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class EnvrcContainsText(Check):
+    name = "direnv.envrc.containsText"
+
+    def __init__(self, expected_string: str, suggestion: str):
+        self.file_path = f"{getcwd()}/.envrc"
+        self.expected_string = expected_string
+        self.pass_fail_message = f"{self.file_path} does <not/> contain '{expected_string}'"
+        self.suggestions = {OS.GENERIC: suggestion}
+
+    def check(self) -> CheckResult:
+        return self.verify(file_contains_text(self.file_path, self.expected_string), self.pass_fail_message)
+
+
+class DirenvAllowed(Check):
+    name = "direnv.allowed"
+    depends_on = [DirenvInstalled, EnvrcContainsText]
+
+    def __init__(self):
+        self.suggestions = {OS.GENERIC: "<cmd>direnv allow .</cmd>"}
+
+    def check(self) -> CheckResult:
+        direnv_status = get_stdout("direnv status")
+        if direnv_status is None:
+            return self.failed("direnv status returned no output")
+        cwd = getcwd()
+        query = f"Found RC path {cwd}/.envrc(\n.*)*Found RC allowed (true|0)"
+        direnv_allowed = re.search(query, direnv_status) is not None
+        return self.verify(direnv_allowed, f"{cwd} is <not/> allowed to use direnv")

daktari/checks/docker.py

@@ -0,0 +1,50 @@
+import logging
+import re
+from typing import Optional
+
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout
+from daktari.os import OS
+from daktari.version_utils import try_parse_semver
+
+
+class DockerInstalled(Check):
+    name = "docker.installed"
+
+    suggestions = {
+        OS.GENERIC: "Install docker: https://docs.docker.com/get-docker/",
+        OS.OS_X: "Install docker: https://docs.docker.com/docker-for-mac/install/",
+    }
+
+    def __init__(self, required_version: Optional[str] = None):
+        self.required_version = required_version
+
+    def check(self) -> CheckResult:
+        installed_version = get_docker_version()
+        return self.validate_semver_expression("Docker", installed_version, self.required_version)
+
+
+major_version_pattern = re.compile("Docker version ([0-9.]+)")
+
+
+def get_docker_version() -> Optional[VersionInfo]:
+    raw_version = get_stdout("docker --version")
+    if raw_version:
+        match = major_version_pattern.search(raw_version)
+        if match:
+            version_string = match.group(1)
+            version = try_parse_semver(version_string)
+            logging.debug(f"Docker version - raw: {version_string}, parsed: {version}")
+            return version
+    return None
+
+
+class DockerComposeInstalled(Check):
+    name = "docker-compose.installed"
+
+    suggestions = {OS.GENERIC: "Install docker-compose: https://docs.docker.com/compose/install/"}
+
+    def check(self) -> CheckResult:
+        return self.verify_install("docker-compose")

daktari/checks/files.py

@@ -0,0 +1,72 @@
+from os.path import expanduser
+from typing import List
+
+from daktari.check import Check, CheckResult
+from daktari.file_utils import dir_exists, file_exists, get_file_owner
+from daktari.os import OS
+
+
+class FilesExist(Check):
+    name = "files.exist"
+    file_paths: List[str] = []
+    pass_fail_message = ""
+
+    def check(self) -> CheckResult:
+        files_exist = all([file_exists(expanduser(file_path)) for file_path in self.file_paths])
+        return self.verify(files_exist, self.pass_fail_message)
+
+
+class FileExists(FilesExist):
+    name = "file.exists"
+
+    def __init__(self, file_path: str, suggestion: str):
+        self.file_paths = [file_path]
+        self.pass_fail_message = f"{file_path} is <not/> present"
+        self.suggestions = {OS.GENERIC: suggestion}
+
+
+class DirsExist(Check):
+    name = "directories.exist"
+    dir_paths: List[str] = []
+    pass_fail_message = ""
+
+    def check(self) -> CheckResult:
+        dirs_exist = all([dir_exists(expanduser(dir_path)) for dir_path in self.dir_paths])
+        return self.verify(dirs_exist, self.pass_fail_message)
+
+
+class DirExists(DirsExist):
+    name = "dir.exists"
+
+    def __init__(self, dir_path: str, suggestion: str):
+        self.dir_paths = [dir_path]
+        self.pass_fail_message = f"{dir_path} is <not/> present"
+        self.suggestions = {OS.GENERIC: suggestion}
+
+
+class FilesOwnedByUser(Check):
+    name = "files.ownedByUser"
+
+    def __init__(
+        self,
+        file_paths: List[str],
+        expected_owner: str = "root",
+        pass_fail_message: str = "",
+        follow_symlinks: bool = False,
+    ):
+        self.file_paths = file_paths
+        self.expected_owner = expected_owner
+        file_paths_str = ", ".join(file_paths)
+        self.pass_fail_message = pass_fail_message or f"{file_paths_str} are <not/> owned by {expected_owner}"
+        self.follow_symlinks = follow_symlinks
+
+    def check(self) -> CheckResult:
+        for file_path in self.file_paths:
+            expanded_file_path = expanduser(file_path)
+            if file_exists(expanded_file_path):
+                if get_file_owner(expanded_file_path, self.follow_symlinks) != self.expected_owner:
+                    return self.verify(False, self.pass_fail_message)
+            else:
+                return self.failed(f"{expanded_file_path} is not present")
+
+        return self.verify(True, self.pass_fail_message)

daktari/checks/flutter.py

@@ -0,0 +1,46 @@
+import logging
+import re
+from semver import VersionInfo
+from typing import Optional
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout
+from daktari.os import OS
+from daktari.version_utils import try_parse_semver
+
+
+flutter_version_pattern = re.compile(r"Flutter\s+([\d\.]+)")
+
+
+def parse_flutter_version_output(version_output: Optional[str]) -> Optional[VersionInfo]:
+    if version_output:
+        match = flutter_version_pattern.search(version_output)
+        if match:
+            version_string = match.group(1)
+            logging.debug(f"Flutter version string: {version_string}")
+            return try_parse_semver(version_string)
+    return None
+
+
+def get_flutter_version() -> Optional[VersionInfo]:
+    version_output = get_stdout("flutter --version")
+    return parse_flutter_version_output(version_output)
+
+
+class FlutterInstalled(Check):
+    name = "flutter.installed"
+
+    suggestions = {
+        OS.GENERIC: "Install Flutter: https://flutter.dev/docs/get-started/install",
+    }
+
+    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:
+        flutter_version = get_flutter_version()
+        logging.info(f"Flutter version: {flutter_version}")
+        return self.validate_semver_expression(
+            "Flutter", flutter_version, self.required_version, self.recommended_version
+        )

daktari/checks/git.py

@@ -0,0 +1,198 @@
+import logging
+from typing import Optional
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import can_run_command, get_stdout
+from daktari.file_utils import file_contains_text, is_ascii
+from daktari.os import OS
+from daktari.version_utils import get_simple_cli_version
+
+
+class GitInstalled(Check):
+    name = "git.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install git</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install git</cmd>",
+        OS.GENERIC: "Install Git: https://git-scm.com/downloads",
+    }
+
+    def check(self) -> CheckResult:
+        if can_run_command("git version"):
+            return self.passed("Git is installed")
+        else:
+            return self.failed("Could not find git on the path")
+
+
+class GitLfsInstalled(Check):
+    name = "git.lfs.installed"
+    depends_on = [GitInstalled]
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install git-lfs</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install git-lfs</cmd>",
+        OS.GENERIC: "Install Git LFS: https://github.com/git-lfs/git-lfs/wiki/Installation",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_command("git lfs version"), "Git LFS is <not/> installed")
+
+
+class GitLfsSetUpForUser(Check):
+    name = "git.lfs.setUpForUser"
+    depends_on = [GitLfsInstalled]
+
+    suggestions = {
+        OS.GENERIC: """
+            Set up Git LFS for your user account:
+            <cmd>git lfs install</cmd>
+            """
+    }
+
+    def check(self) -> CheckResult:
+        output = get_stdout("git lfs env")
+        passed = bool(output and "git-lfs filter-process" in output)
+        return self.verify(passed, "Git LFS is <not/> set up for the current user")
+
+
+class GitLfsFilesDownloaded(Check):
+    name = "git.lfs.filesDownloaded"
+    depends_on = [GitLfsSetUpForUser]
+
+    suggestions = {
+        OS.GENERIC: """
+            Download all Git LFS files and update working copy with the downloaded content:
+            <cmd>git lfs pull</cmd>
+            """
+    }
+
+    def check(self) -> CheckResult:
+        output = get_stdout("git lfs ls-files") or ""
+        files_not_downloaded = [line.split()[2] for line in output.splitlines() if line.split()[1] == "-"]
+        for file in files_not_downloaded:
+            logging.info(f"Git LFS file not downloaded: {file}")
+        passed = len(files_not_downloaded) == 0
+        return self.verify(passed, "Git LFS files have <not/> been downloaded")
+
+
+class GitCryptInstalled(Check):
+    name = "git.crypt.installed"
+    depends_on = [GitInstalled]
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install git-crypt</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install git-crypt</cmd>",
+        OS.GENERIC: "Install git-crypt: https://www.agwa.name/projects/git-crypt/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_command("git crypt version"), "git-crypt is <not/> installed")
+
+
+class GitCryptUnlocked(Check):
+    name = "git.crypt.unlocked"
+    depends_on = [GitCryptInstalled]
+
+    def __init__(self, fileToCheck: str):
+        self.fileToCheck = fileToCheck
+
+    suggestions = {
+        OS.GENERIC: """
+            Unlock this repository with:
+            <cmd>git-crypt unlock</cmd>
+            """,
+    }
+
+    def check(self) -> CheckResult:
+        is_unlocked = is_ascii(self.fileToCheck)
+        return self.verify(is_unlocked, "Encrypted files have <not/> been unlocked")
+
+
+class PreCommitInstalled(Check):
+    name = "preCommit.installed"
+    depends_on = [GitInstalled]
+
+    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.OS_X: "<cmd>brew install pre-commit</cmd>",
+        OS.GENERIC: "Install pre-commit: https://pre-commit.com/#installation",
+    }
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("pre-commit")
+        return self.validate_semver_expression(
+            "pre-commit", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class PreCommitGitHooksInstalled(Check):
+    name = "preCommit.gitHooksInstalled"
+    depends_on = [PreCommitInstalled]
+
+    suggestions = {
+        OS.GENERIC: "<cmd>pre-commit install</cmd>",
+    }
+
+    def check(self) -> CheckResult:
+        git_hooks_installed = file_contains_text(".git/hooks/pre-commit", "pre-commit.com")
+        return self.verify(git_hooks_installed, "pre-commit Git hooks are <not/> installed")
+
+
+class GpgInstalled(Check):
+    name = "gpg.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install gpg2 gnupg pinentry-mac</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install gpg</cmd>",
+        OS.GENERIC: "Install gpg: https://gnupg.org/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("gpg")
+
+
+class GitCommitSigningSetUp(Check):
+    name = "git.commitSigningSetUp"
+
+    suggestions = {
+        OS.OS_X: "Follow instructions to set up commit signing: "
+        "https://gist.github.com/troyfontaine/18c9146295168ee9ca2b30c00bd1b41e#file-2-using-gpg-md",
+        OS.UBUNTU: "Follow instructions to set up commit signing: "
+        "https://brain2life.hashnode.dev/how-to-sign-your-git-commits-in-ubuntu-2004-and-why-you-need-it",
+    }
+
+    def check(self) -> CheckResult:
+        key = get_stdout("git config user.signingkey")
+        passed = key is not None and key != ""
+        return self.verify(passed, "user.signingkey is <not/> set")
+
+
+class GitCommitAutoSigningEnabled(Check):
+    name = "git.commitAutoSigningEnabled"
+    depends_on = [GitCommitSigningSetUp]
+
+    suggestions = {OS.GENERIC: "<cmd>git config commit.gpgsign true</cmd>"}
+
+    def check(self) -> CheckResult:
+        setting = get_stdout("git config commit.gpgsign")
+        passed = setting == "true"
+        return self.verify(passed, "commit.gpgsign is <not/> enabled")
+
+
+class GitCommitSigningFormat(Check):
+    name = "git.commitSigningFormat"
+
+    def __init__(self, required_format: str, suggestion: str):
+        self.required_format = required_format
+        self.suggestions = {OS.GENERIC: suggestion}
+
+    def check(self) -> CheckResult:
+        format_setting = get_stdout("git config gpg.format")
+        return self.verify(
+            format_setting == self.required_format,
+            f"gpg.format is {self.required_format}",
+            f"gpg.format is not {self.required_format}: {format_setting}",
+        )