1#@!#!123s

: / opt / alt / php-xray / php / smart-advice-plugin /
Filename : run.py
back
#!/opt/cloudlinux/venv/bin/python3 -Ibb
##
# Copyright (с) Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2022 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# https://www.cloudlinux.com/legal/
##

import grp
import hashlib
import logging
import os
import re
import pwd
import stat
import subprocess
import sys
import time
import json
import shutil
from dataclasses import dataclass
from enum import Enum, auto

from packaging.version import (
    InvalidVersion,
    Version,
    parse as parse_version
)

from xray.internal.utils import sentry_init
from xray.internal.user_plugin_utils import check_for_root
from xray.analytics import report_analytics
from clcommon.cpapi import getCPName
from clcommon.cpapi.pluginlib import getuser


class Action(Enum):
    INSTALL = auto()
    UNINSTALL = auto()


@dataclass
class Args:
    path_to_php: str
    path_to_wp: str
    path_to_mu_plugin: str
    advice_list_json: str

    emails: str
    login_url: str

    action: Action = Action.INSTALL

@dataclass
class WebsiteInfo:
    php_version: Version

    wp_version: Version
    wp_must_use_plugins_path: str


def _get_wp_cli_environment(disable_smart_advice: bool = False):
    env = dict(SKIP_PLUGINS_LOADING='1')
    if disable_smart_advice:
        env.update(dict(CL_SMART_ADVICE_DISABLED='1'))
    return env


def get_wp_cli_command(args: Args):
    return ["/opt/clwpos/wp-cli-wrapped", args.path_to_php, args.path_to_wp]


def _gather_must_use_plugin_dir(args):
    try:
        must_use_plugin_dir = subprocess.check_output(
            [*get_wp_cli_command(args), 'eval', 'echo WPMU_PLUGIN_DIR;'],
            text=True, env=_get_wp_cli_environment(disable_smart_advice=True),
            stderr=subprocess.PIPE).strip()
    except subprocess.CalledProcessError as e:
        logging.error('Unable to read WPMU_PLUGIN_DIR constant; '
                      '\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s'
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        must_use_plugin_dir = None

    if must_use_plugin_dir:
        return must_use_plugin_dir

    try:
        wp_content_dir = subprocess.check_output(
            [*get_wp_cli_command(args), 'eval', 'echo WP_CONTENT_DIR;'],
            text=True, env=_get_wp_cli_environment(disable_smart_advice=True),
            stderr=subprocess.PIPE).strip()
    except subprocess.CalledProcessError as e:
        logging.error(f"Error reading WordPress constant WP_CONTENT_DIR.; "
                      f"\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s"
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        return None
    else:
        if not wp_content_dir:
            logging.error("The path to the folder with must use plugins is empty.")
            return None
        must_use_plugin_dir = os.path.join(wp_content_dir, 'mu-plugins')


    return must_use_plugin_dir

def _gather_advice_ids(args: Args) -> str:
    try:
        advice_ids = []
        advice_dict = json.loads(args.advice_list_json)
        for advice in advice_dict['data']:
            advice_ids.append(advice['advice']['id'])
        advice_row = ','.join(str(id) for id in advice_ids)
    except (KeyError, ValueError, TypeError):
        logging.error('[Analytics] Unable to get advice list.')
        return None

    return advice_row

def _user_hash(username):
    # when > 1 user
    return ','.join([hashlib.md5(u.encode("utf-8")).hexdigest() for u in username.split(',')])

def prepare_system_analytics_data(user_name: str, user_hash=None, journey_id=None) -> str:
    return json.dumps({
        'user_hash': user_hash or _user_hash(user_name),
        'journey_id': journey_id or 'system',
        'username': user_name
    })


def _report_sync_or_error(args: Args, event: str) -> None:
    """
    Report advice sync status
    """
    username = getuser()
    if username is None:
        return

    analytics_data = prepare_system_analytics_data(username)
    if analytics_data is None:
        return

    advice_id = _gather_advice_ids(args)
    if not advice_id:
        return

    source = getCPName()
    if source is None:
        return
    report_analytics(analytics_data, advice_id, source.lower(), event)


def _gather_wordpress_version(args):
    try:
        wordpress_version_raw = subprocess.check_output(
            [*get_wp_cli_command(args), 'core', 'version'],
            text=True, env=_get_wp_cli_environment(disable_smart_advice=True),
            stderr=subprocess.PIPE).strip()
    except subprocess.CalledProcessError as e:
        logging.error(f"Error happened while reading WordPress versions."
                      f"\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s"
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        return None

    try:
        wordpress_version = parse_version(wordpress_version_raw)
    except InvalidVersion:
        logging.error("WordPress version %s is unparsable.", wordpress_version_raw)
        return None

    if wordpress_version < parse_version('4.6'):
        logging.error("WordPress version %s is not supported.", wordpress_version_raw)
        return None

    return wordpress_version


def _gather_php_version(args: Args):
    try:
        php_version_raw = subprocess.check_output(
            [args.path_to_php, '-r', 'echo PHP_VERSION;'],
            stderr=subprocess.PIPE,
            text=True,
            env=_get_wp_cli_environment(),
        ).strip()
    except subprocess.CalledProcessError as e:
        logging.error('Unable to get php version'
                      f"\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s"
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        return None

    try:
        php_version = parse_version(php_version_raw)
    except InvalidVersion:
        logging.error("PHP version %s cannot be parsed.", php_version_raw)
        return None

    if php_version < parse_version('5.6'):
        logging.error("PHP version %s is not supported.", php_version)
        return None

    return php_version


def gather_information(args: Args):
    if (php_version := _gather_php_version(args)) is None:
        return None

    if (wordpress_version := _gather_wordpress_version(args)) is None:
        return None

    return WebsiteInfo(
        php_version=php_version,
        wp_version=wordpress_version,
        wp_must_use_plugins_path=args.path_to_mu_plugin
    )


def get_file_info(path):
    file_stat = os.stat(path)

    # Get file permissions
    file_permissions = stat.filemode(file_stat.st_mode)

    # Get number of links
    num_links = file_stat.st_nlink

    # Get owner name
    uid = file_stat.st_uid
    owner_name = pwd.getpwuid(uid)[0]

    # Get group name
    gid = file_stat.st_gid
    group_name = grp.getgrgid(gid)[0]

    # Get file size
    file_size = file_stat.st_size

    # Get last modification time
    mod_time = time.strftime('%b %d %H:%M', time.localtime(file_stat.st_mtime))

    return f"{file_permissions} {num_links} {owner_name} {group_name} {file_size} {mod_time}"


def _gather_plugin_version(file_path):
    version = ''
    if os.path.isfile(file_path):
        with open(file_path, 'r') as file:
            content = file.read()
            match = re.search(r'Version:\s+(.*)', content)
            if match:
                version = match.group(1)

    return version


def plugin_installed(mu_plugin_dir):
    plugin_must_use_file = os.path.join(mu_plugin_dir, 'cl-smart-advice.php')
    plugin_must_use_folder = os.path.join(mu_plugin_dir, 'cl-smart-advice')
    return True if os.path.isfile(plugin_must_use_file) and os.path.isdir(plugin_must_use_folder) else False


def plugin_cleanup(mu_plugin_dir):
    if check_for_root():
        raise PermissionError('Root privileges are not allowed to run plugin_cleanup method.')

    plugin_must_use_file = os.path.join(mu_plugin_dir, 'cl-smart-advice.php')
    plugin_must_use_folder = os.path.join(mu_plugin_dir, 'cl-smart-advice')

    # Removing the old version of the plugin installation via a symlink
    if os.path.islink(plugin_must_use_file):
        os.remove(plugin_must_use_file)
        logging.info('Remove outdated plugin symlink in %s.', mu_plugin_dir)

    # The order of deletion matters!
    if os.path.exists(plugin_must_use_file):
        os.remove(plugin_must_use_file)

    if os.path.exists(plugin_must_use_folder):
        shutil.rmtree(plugin_must_use_folder)


def setup_plugin(mu_plugin_dir):
    base_dir = '/opt/alt/php-xray/php/smart-advice-plugin/'

    plugin_file = os.path.join(base_dir, 'cl-smart-advice.php')
    plugin_folder = os.path.join(base_dir, 'cl-smart-advice')
    plugin_version = _gather_plugin_version(plugin_file)

    plugin_must_use_file = os.path.join(mu_plugin_dir, 'cl-smart-advice.php')
    plugin_must_use_folder = os.path.join(mu_plugin_dir, 'cl-smart-advice')
    plugin_must_use_version = _gather_plugin_version(plugin_must_use_file)

    if plugin_installed(mu_plugin_dir) and plugin_version == plugin_must_use_version:
        logging.info('Smart advice plugin %s is already installed in %s, nothing to do.',
                     plugin_version, mu_plugin_dir)
        return

    # Remove outdated items
    plugin_cleanup(mu_plugin_dir)

    try:
        # The copy order matters!
        shutil.copytree(plugin_folder, plugin_must_use_folder)
        shutil.copy2(plugin_file, plugin_must_use_file)
    except OSError as e:
        folder_info = get_file_info(mu_plugin_dir)
        logging.error("Failed copy plugin files. (Folder info: %s). Reason: %s}", folder_info, str(e))
        raise


def install_plugin(wp_site: WebsiteInfo):
    setup_plugin(wp_site.wp_must_use_plugins_path)


def uninstall_plugin(args: Args, wp_site: WebsiteInfo):
    mu_plugin_dir = wp_site.wp_must_use_plugins_path

    if not plugin_installed(mu_plugin_dir):
        logging.info('Smart advice plugin is not installed in %s, nothing to do.', mu_plugin_dir)
        return

    try:
        uninstall_result = subprocess.check_output([
            *get_wp_cli_command(args), 'smart-advice', 'uninstall'],
            text=True,
            stderr=subprocess.PIPE,
            env=_get_wp_cli_environment(),
        ).strip()

        plugin_cleanup(mu_plugin_dir)
    except subprocess.CalledProcessError as e:
        logging.error(f"Error happened while uninstalling WP SmartAdvice plugin"
                      f"\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s"
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        raise


def sync_advice(args: Args, wp_site: WebsiteInfo, data: str):
    try:
        sync_result = subprocess.check_output(
            [*get_wp_cli_command(args), 'smart-advice', 'sync',
             '--list=' + data,
             '--cpanel_url=' + args.login_url,
             '--cpanel_user_emails=' + args.emails],
            text=True,
            stderr=subprocess.PIPE,
            env=_get_wp_cli_environment()
        ).strip()
    except subprocess.CalledProcessError as e:
        logging.error(f"Failed run wp-cli command smart-advice sync."
                      f"\nstdout=`%s`\nstderr=`%s`,\nreturncode=%s"
                      '', e.stdout.strip('\n'), e.stderr.strip('\n'), e.returncode)
        _report_sync_or_error(args, 'advice_sync_failed')
        raise
    else:
        _report_sync_or_error(args, 'advice_synced')


def health_check(args: Args, wp_site: WebsiteInfo):
    try:
        result = subprocess.check_output([*get_wp_cli_command(args), 'option', 'get', 'home'],
                                         env=_get_wp_cli_environment()
                                         ).decode().strip()
    except subprocess.CalledProcessError as e:
        uninstall_plugin(args, wp_site)
        logging.error(f"Failed run wp-cli command, site's health status failed. Plugin removed.")
        raise


def main(args: Args):
    wordpress_website = gather_information(args)
    if not wordpress_website:
        exit(1)

    if args.action == Action.UNINSTALL:
        uninstall_plugin(args, wordpress_website)
    else:
        install_plugin(wordpress_website)
        sync_advice(args, wordpress_website, data=args.advice_list_json)

    health_check(args, wordpress_website)


if __name__ == '__main__':
    sentry_init()

    # FIXME: migrate to proper argparse one day
    def get_action():
        if len(sys.argv) >= 8 and sys.argv[7] == 'true':
            return Action.UNINSTALL
        return Action.INSTALL

    args = Args(
        path_to_php=sys.argv[1],
        path_to_wp=sys.argv[2],
        path_to_mu_plugin=sys.argv[3],
        advice_list_json=sys.argv[4],
        emails=sys.argv[5],
        login_url=sys.argv[6],
        action=get_action()
    )
    logging.info('Arguments received: %s', args)

    main(args)