Mini Shell

"""
This program is free software: you can redistribute it and/or modify it under 
the terms of the GNU General Public License as published by 
the Free Software Foundation, either version 3 of the License, 
or (at your option) any later version.


This program is distributed in the hope that it will be useful, 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
See the GNU General Public License for more details.


You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.

Copyright © 2019 Cloud Linux Software Inc.

This software is also available under ImunifyAV commercial license,
see <https://www.imunify360.com/legal/eula>
"""
import asyncio
import socket
from functools import lru_cache, wraps
from itertools import chain
from pathlib import Path

import yaml

from defence360agent.contracts.config import SimpleRpc as Config
from defence360agent.model.simplification import run_in_executor
from defence360agent.rpc_tools.validate import ValidationError
from defence360agent.utils import antivirus_mode, is_root_user


def is_running():
    """ Check if Agent (or Sensor) instance is running """
    if Config.SOCKET_ACTIVATION:
        # TODO: check that process is exist already
        # As systemd use sockets in antivirus mode
        # we could not use it for check
        return False

    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
        try:
            if is_root_user():
                sock.connect(Config.SOCKET_PATH)
            else:
                sock.connect(Config.NON_ROOT_SOCKET_PATH)
        except (ConnectionRefusedError, FileNotFoundError):
            return False
        else:
            return True


def _find_schema(base=None, schema_dir='schema'):
    p = (base / schema_dir)
    for path in [*p.rglob('*.yaml'), *p.rglob('*.yml')]:
        document = yaml.safe_load(path.read_text())

        for k, v in document.items():
            # converting keys - from strings to tuples
            yield tuple(k.split(' ')), v


@lru_cache(1)
def prepare_schema(paths):
    path = Path(__file__).parent.parent / 'simple_rpc'

    schema = (
        _find_schema(path),
        _find_schema(path.parent / 'feature_management' / 'rpc'),
        _find_schema(path.parent / 'malwarelib' / 'rpc'),
    )
    if antivirus_mode.disabled:  # IM360 is used
        schema += (
            _find_schema(path.parent / 'malwarelib' / 'advanced' / 'rpc'),
        )
    if paths:
        for base_path in paths:
            schema += (_find_schema(base_path), )

    return dict(chain(*schema))


def run_in_executor_decorator(f):
    @wraps(f)
    async def wrapper(*args, **kwargs):
        return await run_in_executor(
            asyncio.get_event_loop(), lambda: f(*args, **kwargs))

    return wrapper


def generate_warnings(affected, not_affected, dest_listname, all_list,
                      success_warning, failure_warning,
                      in_another_list_warning=None):
    """
    :param list affected: IPs that were changed during operation
    :param list of tuples || list of str not_affected: IPs & it's listnames
            that weren't changed during operation
    :param list all_list: list of all IPs that take place in operation
    :param str success_warning: msg if IP was changed
    :param str failure_warning: msg if IPs wasn't changed and it's absent
            in any other lists
    :param str in_another_list_warning: msg if IPs wasn't changed , however
            it present in another list
    :return list of st warnings: msg to be printed
    """
    warnings = []
    for item in not_affected:
        record, listname = item['rec'], item.get('listname', dest_listname)
        if listname and in_another_list_warning:
            warnings.append(
                in_another_list_warning.format(record, listname))
        else:
            warnings.append(failure_warning.format(record, dest_listname))

    num_deleted = len(affected)
    total_num = len(all_list)

    if total_num > 1 and total_num != num_deleted:
        warnings.append(success_warning.format(num_deleted, total_num))

    if warnings:
        raise ValidationError(warnings)

    return {}