Edit

[EDIT] FILE: service_manager.py

"""
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/>.

This software is also available under ImunifyAV commercial license,
see <https://www.imunify360.com/legal/eula>

AV services manager plugin.

Manages patchman service based on imunify config changes.
Runs on both AV-only and IM360 installations.
"""

import logging

from defence360agent import utils
from defence360agent.contracts import messages, plugins
from defence360agent.plugins.service_manager import BaseServiceManager
from defence360agent.subsys import svcctl
from imav.contracts.config import Patchman
from imav.patchman.constants import PATCHMAN_SERVICE_NAME
from imav.patchman.state import is_installed as is_patchman_installed

__all__ = ["ServiceManager"]

logger = logging.getLogger(__name__)

class ServiceManager(BaseServiceManager):
    """AV service manager: manages patchman service."""

SCOPE = utils.Scope.AV_IM360

# released im360 ServiceManager subclasses call the private base
    # method through this class's mangled name; keep the alias so a
    # newer antivirus package works with an older im360 package
    _ServiceManager__ensure_service_status = (
        BaseServiceManager._ensure_service_status
    )

def __init__(self, *, unitctl=None):
        super().__init__()
        self._services = [self._ensure_consistent_patchman_state]
        self._units = {
            "patchman": unitctl or svcctl.adaptor(PATCHMAN_SERVICE_NAME),
        }

async def create_sink(self, loop):
        pass

@plugins.expect(
        messages.MessageType.EnsureServiceState, service=PATCHMAN_SERVICE_NAME
    )
    async def ensure_patchman_state(
        self, message: messages.MessageType.EnsureServiceState
    ):
        async with self._lock:
            await self._ensure_consistent_patchman_state()

async def _ensure_consistent_patchman_state(self) -> None:
        if is_patchman_installed():
            await self._ensure_service_status(
                self._units["patchman"],
                PATCHMAN_SERVICE_NAME,
                Patchman.ENABLED,
            )

CANCEL