Elep

# -*- coding: utf-8 -*-

# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2021 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT

from __future__ import absolute_import

import subprocess
from typing import Optional, Tuple, Dict
from clwpos import gettext as _

from clcommon.utils import ExternalProgramFailed, run_command
from clwpos.cl_wpos_exceptions import WposError

class DeadRedisPurgeAttempt(WposError):
    """
    Happens when somebody tries to purge
    redis instance which is not runnning
    """

def __init__(self):
        super().__init__(message=_(
            "Unable to purge cache because cache database is not running. "
            "Enable at least one optimization feature to start cache database instance."))

class PurgeFailedError(WposError):
    """
    Happens when redis is not able to purge cached data for some reason.
    """

def __init__(self, std_out: str, std_err: str):
        super().__init__(
            message=_('Unable to purge cache. \n'
                      'Database backend returned error of command "%(command)s" execution. '
                      'Try again a bit later or contact your system administrator for help.'),
            details='stdout: \n<i>%(stdout)s</i>\n'
                    'stderr: \n<i>%(stderr)s</i>\n',

context={
                "command": 'purge',
                "stdout": std_out or 'empty',
                "stderr": std_err or 'empty',
            })

class RedisLibUser(object):

def __init__(self, socket_path: str,
                 redis_cli_path: str = "/opt/alt/redis/bin/redis-cli") -> None:
        self.socket_path = socket_path
        self.redis_cli_path = redis_cli_path

def get_redis_shell_command(self, redis_command):
        return [
            self.redis_cli_path,
            "-s",
            self.socket_path,
        ] + redis_command.split(" ")

def run_redis_command(self, command: str) -> Tuple[int, str, str]:
        redis_command = self.get_redis_shell_command(command)
        try:
            returncode, std_out, std_err = run_command(
                redis_command, return_full_output=True
            )
        except (subprocess.CalledProcessError, ExternalProgramFailed) as error:
            raise WposError(
                message=_("Error during %(command)s command execution: \n%(error)s"),
                context={"command": " ".join(redis_command), "error": str(error)},
            )
        return returncode, std_out, std_err

def purge_redis(self) -> Dict:
        """
        Clean entire redis cache for user.
        """
        if not self.is_redis_alive():
            raise DeadRedisPurgeAttempt()

purge_command = "flushall async"
        returncode, std_out, std_err = self.run_redis_command(purge_command)
        # Output of Redis FLUSHALL command should be: "OK"
        if returncode != 0 or "ok" not in std_out.lower():
            raise PurgeFailedError(std_out, std_err)

return {
            "used_memory": self.get_redis_used_memory()
        }

def is_redis_alive(self) -> bool:
        """
        Check if user's redis is alive.
        """
        returncode, std_out, _ = self.run_redis_command("ping")
        return returncode == 0 and "pong" in std_out.lower()

def is_redis_empty(self) -> bool:
        """
        Check if user's redis is empty.
        Example (redis is empty):
            # Keyspace
        Example (redis is NOT empty):
            # Keyspace
            db0:keys=2,expires=0,avg_ttl=0
        """
        returncode, std_out, _ = self.run_redis_command("info keyspace")
        return returncode == 0 and len(std_out.strip().split("\n")) <= 1

def get_redis_used_memory(self) -> Optional[str]:
        """
        Return amount of memmory used by user's redis instance
        in human readable format (kb or mb).
        If redis status is offline, 'used_memory_value' value is null.
        'info memory' command output:
            # Memory
            used_memory:369616
            used_memory_human:360.95K
            ...
        """
        _, std_out, _ = self.run_redis_command("info memory")
        for line in std_out.split("\n"):
            if not line.startswith("used_memory_human"):
                continue
            _, used_memory_value = line.split(":")
            return used_memory_value if used_memory_value != "null" else None