Mini Shell

#!/opt/cloudlinux/venv/bin/python3 -bb
# -*- coding: utf-8 -*-

# clwposcron Utility to scan domains for Cloudlinux WPOS requirements by cron
#
# 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

# pylint: disable=no-absolute-import

import os
import time
import subprocess
import logging
import json

from clwpos.logsetup import setup_logging


class CloudlinuxWposReqScanner(object):
    """
    Class for run clwposcron functionality
    """
    TIMEOUT_24H_SECONDS = 24 * 3600
    _CRON_LOG_FILE = '/var/log/clwpos/req_cron.log'

    def __init__(self):
        self._file_flag_force_check = '/var/lve/clwpos/cl_wpos_scan_req_force'
        self._scan_req_scan_last_ts = '/var/lve/clwpos/cl_wpos_scan_req_last_ts'
        self._logger = setup_logging(
            caller_name='clwpos_req_cron',
            # Uncomment this for console debug
            # console_level=logging.DEBUG,
            file_level=logging.INFO,
            logfile_path=self._CRON_LOG_FILE
        )

    def _get_last_start_time(self) -> float:
        """
        Get last time start time from file
        :return: Last start time as UNIX timestamp
        """
        try:
            with open(self._scan_req_scan_last_ts, 'r') as f:
                s_last_ts = f.read()
            last_ts = float(s_last_ts)
        except (OSError, IOError, ValueError):
            last_ts = 0.0
        return last_ts

    def _save_last_start_time(self, last_time: float):
        """
        Save last time to file
        :param last_time: Last time (UNIX timestamp) to save
        """
        with open(self._scan_req_scan_last_ts, 'w') as f:
            f.write(str(last_time))

    def _is_24h_passed(self, ts_now: float) -> bool:
        """
        Check is 24h interval passed
        :param ts_now: 'now' UNIX timestamp
        :return: True - passed, False - not passed
        """
        last_ts = self._get_last_start_time()
        if last_ts != 0.0 and ts_now - last_ts < self.TIMEOUT_24H_SECONDS:
            # 24h not passed
            return False
        return True

    def run(self):
        """
        Run command action
        """
        self._logger.debug("CL AWP requirements cron script started")
        try:
            if not os.path.exists(self._file_flag_force_check):
                # force start flag file absent, check 24h timeout
                ts_now = time.time()
                is_24h_passed = self._is_24h_passed(ts_now)
                if not is_24h_passed:
                    # 24h not passed from last run this script - do nothing
                    self._logger.debug("24 hours not passed - do nothing")
                    return 0
                # timestamp file old/absent, create it
                self._save_last_start_time(ts_now)
            else:
                self._logger.info("Force start")
                # Force start
                try:
                    os.remove(self._file_flag_force_check)
                except (OSError, IOError):
                    self._logger.exception(f'{self._file_flag_force_check} remove error', exc_info=True)
            # Run file generation
            try:
                # /usr/bin/clwpos-admin generate-report --all
                proc = subprocess.Popen(['/usr/bin/clwpos-admin', 'generate-report', '--all'],
                                        shell=False,
                                        stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
                stdout, stderr = proc.communicate()
                if proc.returncode != 0:
                    self._logger.warning('/usr/bin/clwpos-admin generate-report start error: retcode=%d\n'
                                         'stdout: %s\nstderr: %s', proc.returncode, stdout, stderr)
                result_dict = json.loads(stdout)
                if result_dict['result'] != 'success':
                    self._logger.info(f'/usr/bin/clwpos-admin generate-report result: {stdout}')
                    self._logger.warning('/usr/bin/clwpos-admin generate-report error')
            except (OSError, IOError, json.JSONDecodeError, KeyError):
                self._logger.exception('/usr/bin/clwpos-admin generate-report start exception', exc_info=True)
        except:
            self._logger.exception('CL AWP requirements cron script general error', exc_info=True)
        return 0